sig
  module Std :
    sig
      module type Node =
        sig
          type t
          type graph
          type label
          type edge
          val create : Graphlib.Std.Node.label -> Graphlib.Std.Node.t
          val label : Graphlib.Std.Node.t -> Graphlib.Std.Node.label
          val mem : Graphlib.Std.Node.t -> Graphlib.Std.Node.graph -> bool
          val succs :
            Graphlib.Std.Node.t ->
            Graphlib.Std.Node.graph -> Graphlib.Std.Node.t Regular.Std.seq
          val preds :
            Graphlib.Std.Node.t ->
            Graphlib.Std.Node.graph -> Graphlib.Std.Node.t Regular.Std.seq
          val inputs :
            Graphlib.Std.Node.t ->
            Graphlib.Std.Node.graph -> Graphlib.Std.Node.edge Regular.Std.seq
          val outputs :
            Graphlib.Std.Node.t ->
            Graphlib.Std.Node.graph -> Graphlib.Std.Node.edge Regular.Std.seq
          val degree :
            ?dir:[ `In | `Out ] ->
            Graphlib.Std.Node.t -> Graphlib.Std.Node.graph -> int
          val insert :
            Graphlib.Std.Node.t ->
            Graphlib.Std.Node.graph -> Graphlib.Std.Node.graph
          val update :
            Graphlib.Std.Node.t ->
            Graphlib.Std.Node.label ->
            Graphlib.Std.Node.graph -> Graphlib.Std.Node.graph
          val remove :
            Graphlib.Std.Node.t ->
            Graphlib.Std.Node.graph -> Graphlib.Std.Node.graph
          val has_edge :
            Graphlib.Std.Node.t ->
            Graphlib.Std.Node.t -> Graphlib.Std.Node.graph -> bool
          val edge :
            Graphlib.Std.Node.t ->
            Graphlib.Std.Node.t ->
            Graphlib.Std.Node.graph -> Graphlib.Std.Node.edge option
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val comparator :
            (t, comparator_witness) Base__.Comparator.comparator
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          module Map :
            sig
              module Key :
                sig
                  type t = t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> string) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__017_) ->
                          Sexplib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Core_map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn :
                (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> string) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a)
                Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__018_) ->
                      Sexplib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : Key.t Bin_prot.Type_class.t
                           val bin_read_t : Key.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Key.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Key.t Bin_prot.Type_class.reader
                           val bin_size_t : Key.t Bin_prot.Size.sizer
                           val bin_write_t : Key.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Key.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Key.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Sexplib.Sexp.t -> 'a) ->
                Base__.Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Sexplib.Sexp.t) ->
                'a t -> Base__.Sexplib.Sexp.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = Map.Key.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Core_set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t option) -> t
                  val of_tree : t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              type t = (Elt.t, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t ->
                   ('b, 'stop)
                   Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                ('b, 'stop)
                Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t)
                Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys :
                (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : Elt.t Bin_prot.Type_class.t
                           val bin_read_t : Elt.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Elt.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Elt.t Bin_prot.Type_class.reader
                           val bin_size_t : Elt.t Bin_prot.Size.sizer
                           val bin_write_t : Elt.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Elt.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Elt.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Sexplib.Sexp.t
            end
          val hash : t -> Core_kernel__.Import.int
          val compare : t -> t -> Core_kernel__.Import.int
          val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl =
                  ('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val iter_vals : 'b t -> f:('-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val replace : 'b t -> key:key -> data:'-> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_or_error :
                'b t -> key:key -> data:'-> unit Base__.Or_error.t
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val replace_all : 'b t -> f:('-> 'b) -> unit
              val replace_alli : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_replace_all : 'b t -> f:('-> 'b option) -> unit
              val filter_replace_alli :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> string) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__001_) ->
                      Sexplib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'v_x__002_) ->
                Sexplib.Sexp.t -> 'v_x__002_ t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              module Provide_of_sexp :
                functor
                  (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Sexplib.Sexp.t -> t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = Hash_set.elt
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val compare : t -> t -> int
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                ('accum, 'stop)
                Base.Container_intf.Finished_or_stopped_early.t
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
              val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val keys : 'a t -> Key.t Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
              val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
            end
        end
      module type Edge =
        sig
          type t
          type node
          type graph
          type label
          val create :
            Graphlib.Std.Edge.node ->
            Graphlib.Std.Edge.node ->
            Graphlib.Std.Edge.label -> Graphlib.Std.Edge.t
          val label : Graphlib.Std.Edge.t -> Graphlib.Std.Edge.label
          val src : Graphlib.Std.Edge.t -> Graphlib.Std.Edge.node
          val dst : Graphlib.Std.Edge.t -> Graphlib.Std.Edge.node
          val mem : Graphlib.Std.Edge.t -> Graphlib.Std.Edge.graph -> bool
          val insert :
            Graphlib.Std.Edge.t ->
            Graphlib.Std.Edge.graph -> Graphlib.Std.Edge.graph
          val update :
            Graphlib.Std.Edge.t ->
            Graphlib.Std.Edge.label ->
            Graphlib.Std.Edge.graph -> Graphlib.Std.Edge.graph
          val remove :
            Graphlib.Std.Edge.t ->
            Graphlib.Std.Edge.graph -> Graphlib.Std.Edge.graph
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val comparator :
            (t, comparator_witness) Base__.Comparator.comparator
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          module Map :
            sig
              module Key :
                sig
                  type t = t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> string) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__017_) ->
                          Sexplib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Core_map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn :
                (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> string) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a)
                Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__018_) ->
                      Sexplib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : Key.t Bin_prot.Type_class.t
                           val bin_read_t : Key.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Key.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Key.t Bin_prot.Type_class.reader
                           val bin_size_t : Key.t Bin_prot.Size.sizer
                           val bin_write_t : Key.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Key.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Key.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Sexplib.Sexp.t -> 'a) ->
                Base__.Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Sexplib.Sexp.t) ->
                'a t -> Base__.Sexplib.Sexp.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = Map.Key.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Core_set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t option) -> t
                  val of_tree : t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              type t = (Elt.t, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t ->
                   ('b, 'stop)
                   Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                ('b, 'stop)
                Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t)
                Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys :
                (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : Elt.t Bin_prot.Type_class.t
                           val bin_read_t : Elt.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Elt.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Elt.t Bin_prot.Type_class.reader
                           val bin_size_t : Elt.t Bin_prot.Size.sizer
                           val bin_write_t : Elt.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Elt.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Elt.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Sexplib.Sexp.t
            end
          val hash : t -> Core_kernel__.Import.int
          val compare : t -> t -> Core_kernel__.Import.int
          val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl =
                  ('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val iter_vals : 'b t -> f:('-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val replace : 'b t -> key:key -> data:'-> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_or_error :
                'b t -> key:key -> data:'-> unit Base__.Or_error.t
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val replace_all : 'b t -> f:('-> 'b) -> unit
              val replace_alli : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_replace_all : 'b t -> f:('-> 'b option) -> unit
              val filter_replace_alli :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> string) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__001_) ->
                      Sexplib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'v_x__002_) ->
                Sexplib.Sexp.t -> 'v_x__002_ t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              module Provide_of_sexp :
                functor
                  (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Sexplib.Sexp.t -> t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = Hash_set.elt
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val compare : t -> t -> int
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                ('accum, 'stop)
                Base.Container_intf.Finished_or_stopped_early.t
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
              val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val keys : 'a t -> Key.t Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
              val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
            end
        end
      module type Graph =
        sig
          type t
          type node
          type edge
          module Node :
            sig
              type t = node
              type graph = t
              type label
              type edge = edge
              val create : label -> t
              val label : t -> label
              val mem : t -> graph -> bool
              val succs : t -> graph -> t Regular.Std.seq
              val preds : t -> graph -> t Regular.Std.seq
              val inputs : t -> graph -> edge Regular.Std.seq
              val outputs : t -> graph -> edge Regular.Std.seq
              val degree : ?dir:[ `In | `Out ] -> t -> graph -> int
              val insert : t -> graph -> graph
              val update : t -> label -> graph -> graph
              val remove : t -> graph -> graph
              val has_edge : t -> t -> graph -> bool
              val edge : t -> t -> graph -> edge option
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val min : t -> t -> t
              val max : t -> t -> t
              val ascending : t -> t -> int
              val descending : t -> t -> int
              val between : t -> low:t -> high:t -> bool
              val clamp_exn : t -> min:t -> max:t -> t
              val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
              type comparator_witness
              val comparator :
                (t, comparator_witness) Base__.Comparator.comparator
              val validate_lbound :
                min:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_ubound :
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_bound :
                min:t Base__.Maybe_bound.t ->
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              module Replace_polymorphic_compare :
                sig
                  val ( >= ) : t -> t -> bool
                  val ( <= ) : t -> t -> bool
                  val ( = ) : t -> t -> bool
                  val ( > ) : t -> t -> bool
                  val ( < ) : t -> t -> bool
                  val ( <> ) : t -> t -> bool
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val min : t -> t -> t
                  val max : t -> t -> t
                end
              module Map :
                sig
                  module Key :
                    sig
                      type t = node
                      val t_of_sexp : Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      type comparator_witness = comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type 'a t =
                          (node, 'a, comparator_witness)
                          Core_kernel__.Core_map_intf.Tree.t
                      val empty : 'a t
                      val singleton : node -> '-> 'a t
                      val of_alist :
                        (node * 'a) list ->
                        [ `Duplicate_key of node | `Ok of 'a t ]
                      val of_alist_or_error :
                        (node * 'a) list -> 'a t Base__.Or_error.t
                      val of_alist_exn : (node * 'a) list -> 'a t
                      val of_alist_multi : (node * 'a) list -> 'a list t
                      val of_alist_fold :
                        (node * 'a) list ->
                        init:'-> f:('-> '-> 'b) -> 'b t
                      val of_alist_reduce :
                        (node * 'a) list -> f:('-> '-> 'a) -> 'a t
                      val of_sorted_array :
                        (node * 'a) array -> 'a t Base__.Or_error.t
                      val of_sorted_array_unchecked :
                        (node * 'a) array -> 'a t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> node * 'a) -> 'a t
                      val of_iteri :
                        iteri:(f:(key:node -> data:'-> unit) -> unit) ->
                        [ `Duplicate_key of node | `Ok of 'v t ]
                      val of_tree : 'a t -> 'a t
                      val of_hashtbl_exn :
                        (node, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                      val gen :
                        node Core_kernel__.Quickcheck.Generator.t ->
                        'Core_kernel__.Quickcheck.Generator.t ->
                        'a t Core_kernel__.Quickcheck.Generator.t
                      val invariants : 'a t -> bool
                      val is_empty : 'a t -> bool
                      val length : 'a t -> int
                      val add : 'a t -> key:node -> data:'-> 'a t
                      val add_multi :
                        'a list t -> key:node -> data:'-> 'a list t
                      val remove_multi : 'a list t -> node -> 'a list t
                      val change :
                        'a t -> node -> f:('a option -> 'a option) -> 'a t
                      val update :
                        'a t -> node -> f:('a option -> 'a) -> 'a t
                      val find : 'a t -> node -> 'a option
                      val find_exn : 'a t -> node -> 'a
                      val remove : 'a t -> node -> 'a t
                      val mem : 'a t -> node -> bool
                      val iter_keys : 'a t -> f:(node -> unit) -> unit
                      val iter : 'a t -> f:('-> unit) -> unit
                      val iteri :
                        'a t -> f:(key:node -> data:'-> unit) -> unit
                      val iter2 :
                        'a t ->
                        'b t ->
                        f:(key:node ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           unit) ->
                        unit
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val mapi :
                        'a t -> f:(key:node -> data:'-> 'b) -> 'b t
                      val fold :
                        'a t ->
                        init:'-> f:(key:node -> data:'-> '-> 'b) -> 'b
                      val fold_right :
                        'a t ->
                        init:'-> f:(key:node -> data:'-> '-> 'b) -> 'b
                      val fold2 :
                        'a t ->
                        'b t ->
                        init:'->
                        f:(key:node ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           '-> 'c) ->
                        'c
                      val filter_keys : 'a t -> f:(node -> bool) -> 'a t
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filteri :
                        'a t -> f:(key:node -> data:'-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                      val filter_mapi :
                        'a t -> f:(key:node -> data:'-> 'b option) -> 'b t
                      val partition_mapi :
                        'a t ->
                        f:(key:node -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                        'b t * 'c t
                      val partition_map :
                        'a t ->
                        f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                      val partitioni_tf :
                        'a t ->
                        f:(key:node -> data:'-> bool) -> 'a t * 'a t
                      val partition_tf :
                        'a t -> f:('-> bool) -> 'a t * 'a t
                      val compare_direct :
                        ('-> '-> int) -> 'a t -> 'a t -> int
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val keys : 'a t -> node list
                      val data : 'a t -> 'a list
                      val to_alist :
                        ?key_order:[ `Decreasing | `Increasing ] ->
                        'a t -> (node * 'a) list
                      val validate :
                        name:(node -> string) ->
                        'Base__.Validate.check ->
                        'a t Base__.Validate.check
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:node ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      val symmetric_diff :
                        'a t ->
                        'a t ->
                        data_equal:('-> '-> bool) ->
                        (node, 'a)
                        Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                        Base__.Sequence.t
                      val min_elt : 'a t -> (node * 'a) option
                      val min_elt_exn : 'a t -> node * 'a
                      val max_elt : 'a t -> (node * 'a) option
                      val max_elt_exn : 'a t -> node * 'a
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val for_alli :
                        'a t -> f:(key:node -> data:'-> bool) -> bool
                      val exists : 'a t -> f:('-> bool) -> bool
                      val existsi :
                        'a t -> f:(key:node -> data:'-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val counti :
                        'a t -> f:(key:node -> data:'-> bool) -> int
                      val split :
                        'a t -> node -> 'a t * (node * 'a) option * 'a t
                      val append :
                        lower_part:'a t ->
                        upper_part:'a t ->
                        [ `Ok of 'a t | `Overlapping_key_ranges ]
                      val subrange :
                        'a t ->
                        lower_bound:node Base__.Maybe_bound.t ->
                        upper_bound:node Base__.Maybe_bound.t -> 'a t
                      val fold_range_inclusive :
                        'a t ->
                        min:node ->
                        max:node ->
                        init:'-> f:(key:node -> data:'-> '-> 'b) -> 'b
                      val range_to_alist :
                        'a t -> min:node -> max:node -> (node * 'a) list
                      val closest_key :
                        'a t ->
                        [ `Greater_or_equal_to
                        | `Greater_than
                        | `Less_or_equal_to
                        | `Less_than ] -> node -> (node * 'a) option
                      val nth : 'a t -> int -> (node * 'a) option
                      val nth_exn : 'a t -> int -> node * 'a
                      val rank : 'a t -> node -> int option
                      val to_tree : 'a t -> 'a t
                      val to_sequence :
                        ?order:[ `Decreasing_key | `Increasing_key ] ->
                        ?keys_greater_or_equal_to:node ->
                        ?keys_less_or_equal_to:node ->
                        'a t -> (node * 'a) Base__.Sequence.t
                      val obs :
                        node Core_kernel__.Quickcheck.Observer.t ->
                        'Core_kernel__.Quickcheck.Observer.t ->
                        'v t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        node Core_kernel__.Quickcheck.Shrinker.t ->
                        'Core_kernel__.Quickcheck.Shrinker.t ->
                        'v t Core_kernel__.Quickcheck.Shrinker.t
                      module Provide_of_sexp :
                        functor
                          (K : sig val t_of_sexp : Sexplib.Sexp.t -> node end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__017_) ->
                              Sexplib.Sexp.t -> 'v_x__017_ t
                          end
                      val t_of_sexp :
                        (Base__.Sexplib.Sexp.t -> 'a) ->
                        Base__.Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Base__.Sexplib.Sexp.t) ->
                        'a t -> Base__.Sexplib.Sexp.t
                    end
                  type 'a t =
                      (node, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Map.t
                  val compare :
                    ('-> '-> Core_kernel__.Import.int) ->
                    'a t -> 'a t -> Core_kernel__.Import.int
                  val empty : 'a t
                  val singleton : node -> '-> 'a t
                  val of_alist :
                    (node * 'a) list ->
                    [ `Duplicate_key of node | `Ok of 'a t ]
                  val of_alist_or_error :
                    (node * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (node * 'a) list -> 'a t
                  val of_alist_multi : (node * 'a) list -> 'a list t
                  val of_alist_fold :
                    (node * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (node * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (node * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (node * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> node * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:node -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of node | `Ok of 'v t ]
                  val of_tree : 'Tree.t -> 'a t
                  val of_hashtbl_exn :
                    (node, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    node Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:node -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:node -> data:'-> 'a list t
                  val remove_multi : 'a list t -> node -> 'a list t
                  val change :
                    'a t -> node -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> node -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> node -> 'a option
                  val find_exn : 'a t -> node -> 'a
                  val remove : 'a t -> node -> 'a t
                  val mem : 'a t -> node -> bool
                  val iter_keys : 'a t -> f:(node -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri : 'a t -> f:(key:node -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:node ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:node -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:node -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:node -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:node ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(node -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:node -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:node -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:node -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:node -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> node list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (node * 'a) list
                  val validate :
                    name:(node -> string) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:node ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (node, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (node * 'a) option
                  val min_elt_exn : 'a t -> node * 'a
                  val max_elt : 'a t -> (node * 'a) option
                  val max_elt_exn : 'a t -> node * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:node -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:node -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti : 'a t -> f:(key:node -> data:'-> bool) -> int
                  val split :
                    'a t -> node -> 'a t * (node * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:node Base__.Maybe_bound.t ->
                    upper_bound:node Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:node ->
                    max:node ->
                    init:'-> f:(key:node -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:node -> max:node -> (node * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> node -> (node * 'a) option
                  val nth : 'a t -> int -> (node * 'a) option
                  val nth_exn : 'a t -> int -> node * 'a
                  val rank : 'a t -> node -> int option
                  val to_tree : 'a t -> 'Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:node ->
                    ?keys_less_or_equal_to:node ->
                    'a t -> (node * 'a) Base__.Sequence.t
                  val obs :
                    node Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    node Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (Key : sig val t_of_sexp : Sexplib.Sexp.t -> node end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__018_) ->
                          Sexplib.Sexp.t -> 'v_x__018_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : node Bin_prot.Type_class.t
                               val bin_read_t : node Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> node)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 node Bin_prot.Type_class.reader
                               val bin_size_t : node Bin_prot.Size.sizer
                               val bin_write_t : node Bin_prot.Write.writer
                               val bin_writer_t :
                                 node Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                        val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                        val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                        val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                        val __bin_read_t__ :
                          ('a, int -> 'a t) Bin_prot.Read.reader1
                        val bin_writer_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.writer
                        val bin_reader_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.reader
                        val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                      end
                  module Provide_hash :
                    functor
                      (Key : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 node -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          (Ppx_hash_lib.Std.Hash.state ->
                           '-> Ppx_hash_lib.Std.Hash.state) ->
                          Ppx_hash_lib.Std.Hash.state ->
                          'a t -> Ppx_hash_lib.Std.Hash.state
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              module Set :
                sig
                  module Elt :
                    sig
                      type t = node
                      val t_of_sexp : Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      type comparator_witness = Map.Key.comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type t =
                          (node, comparator_witness)
                          Core_kernel__.Core_set_intf.Tree.t
                      val compare : t -> t -> Core_kernel__.Import.int
                      val length : t -> int
                      val is_empty : t -> bool
                      val iter : t -> f:(node -> unit) -> unit
                      val fold :
                        t ->
                        init:'accum -> f:('accum -> node -> 'accum) -> 'accum
                      val fold_result :
                        t ->
                        init:'accum ->
                        f:('accum -> node -> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val exists : t -> f:(node -> bool) -> bool
                      val for_all : t -> f:(node -> bool) -> bool
                      val count : t -> f:(node -> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        t -> f:(node -> 'sum) -> 'sum
                      val find : t -> f:(node -> bool) -> node option
                      val find_map : t -> f:(node -> 'a option) -> 'a option
                      val to_list : t -> node list
                      val to_array : t -> node array
                      val invariants : t -> bool
                      val mem : t -> node -> bool
                      val add : t -> node -> t
                      val remove : t -> node -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val symmetric_diff :
                        t ->
                        t -> (node, node) Base__.Either.t Base__.Sequence.t
                      val compare_direct : t -> t -> int
                      val equal : t -> t -> bool
                      val is_subset : t -> of_:t -> bool
                      val subset : t -> t -> bool
                      val fold_until :
                        t ->
                        init:'->
                        f:('->
                           node ->
                           ('b, 'stop)
                           Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                        ('b, 'stop)
                        Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                      val fold_right :
                        t -> init:'-> f:(node -> '-> 'b) -> 'b
                      val iter2 :
                        t ->
                        t ->
                        f:([ `Both of node * node
                           | `Left of node
                           | `Right of node ] -> unit) ->
                        unit
                      val filter : t -> f:(node -> bool) -> t
                      val partition_tf : t -> f:(node -> bool) -> t * t
                      val elements : t -> node list
                      val min_elt : t -> node option
                      val min_elt_exn : t -> node
                      val max_elt : t -> node option
                      val max_elt_exn : t -> node
                      val choose : t -> node option
                      val choose_exn : t -> node
                      val split : t -> node -> t * node option * t
                      val group_by :
                        t -> equiv:(node -> node -> bool) -> t list
                      val find_exn : t -> f:(node -> bool) -> node
                      val find_index : t -> int -> node option
                      val nth : t -> int -> node option
                      val remove_index : t -> int -> t
                      val to_tree : t -> t
                      val to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:node ->
                        ?less_or_equal_to:node -> t -> node Base__.Sequence.t
                      val merge_to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:node ->
                        ?less_or_equal_to:node ->
                        t ->
                        t ->
                        (node, node)
                        Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                        Base__.Sequence.t
                      val to_map :
                        t ->
                        f:(node -> 'data) ->
                        (node, 'data, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t
                      val obs :
                        node Core_kernel__.Quickcheck.Observer.t ->
                        t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        node Core_kernel__.Quickcheck.Shrinker.t ->
                        t Core_kernel__.Quickcheck.Shrinker.t
                      val empty : t
                      val singleton : node -> t
                      val union_list : t list -> t
                      val of_list : node list -> t
                      val of_array : node array -> t
                      val of_sorted_array : node array -> t Base__.Or_error.t
                      val of_sorted_array_unchecked : node array -> t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> node) -> t
                      val stable_dedup_list : node list -> node list
                      val map :
                        ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                        f:('-> node) -> t
                      val filter_map :
                        ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                        f:('-> node option) -> t
                      val of_tree : t -> t
                      val of_hash_set : node Core_kernel__.Hash_set.t -> t
                      val of_hashtbl_keys :
                        (node, 'a) Core_kernel__.Core_hashtbl.t -> t
                      val of_map_keys :
                        (node, 'a, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t -> t
                      val gen :
                        node Core_kernel__.Quickcheck.Generator.t ->
                        t Core_kernel__.Quickcheck.Generator.t
                      module Provide_of_sexp :
                        functor
                          (Elt : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> node
                                 end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                    end
                  type t = (node, comparator_witness) Base.Set.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(node -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> node -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> node -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(node -> bool) -> bool
                  val for_all : t -> f:(node -> bool) -> bool
                  val count : t -> f:(node -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(node -> 'sum) -> 'sum
                  val find : t -> f:(node -> bool) -> node option
                  val find_map : t -> f:(node -> 'a option) -> 'a option
                  val to_list : t -> node list
                  val to_array : t -> node array
                  val invariants : t -> bool
                  val mem : t -> node -> bool
                  val add : t -> node -> t
                  val remove : t -> node -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t -> t -> (node, node) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       node ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right : t -> init:'-> f:(node -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of node * node
                       | `Left of node
                       | `Right of node ] -> unit) ->
                    unit
                  val filter : t -> f:(node -> bool) -> t
                  val partition_tf : t -> f:(node -> bool) -> t * t
                  val elements : t -> node list
                  val min_elt : t -> node option
                  val min_elt_exn : t -> node
                  val max_elt : t -> node option
                  val max_elt_exn : t -> node
                  val choose : t -> node option
                  val choose_exn : t -> node
                  val split : t -> node -> t * node option * t
                  val group_by : t -> equiv:(node -> node -> bool) -> t list
                  val find_exn : t -> f:(node -> bool) -> node
                  val find_index : t -> int -> node option
                  val nth : t -> int -> node option
                  val remove_index : t -> int -> t
                  val to_tree : t -> Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:node ->
                    ?less_or_equal_to:node -> t -> node Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:node ->
                    ?less_or_equal_to:node ->
                    t ->
                    t ->
                    (node, node)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(node -> 'data) ->
                    (node, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    node Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    node Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : node -> t
                  val union_list : t list -> t
                  val of_list : node list -> t
                  val of_array : node array -> t
                  val of_sorted_array : node array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : node array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> node) -> t
                  val stable_dedup_list : node list -> node list
                  val map : ('a, 'b) Base.Set.t -> f:('-> node) -> t
                  val filter_map :
                    ('a, 'b) Base.Set.t -> f:('-> node option) -> t
                  val of_tree : Tree.t -> t
                  val of_hash_set : node Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (node, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (node, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    node Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> node end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (Elt : sig
                               val bin_t : node Bin_prot.Type_class.t
                               val bin_read_t : node Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> node)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 node Bin_prot.Type_class.reader
                               val bin_size_t : node Bin_prot.Size.sizer
                               val bin_write_t : node Bin_prot.Write.writer
                               val bin_writer_t :
                                 node Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                        val bin_shape_t : Bin_prot.Shape.t
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_t : t Bin_prot.Type_class.t
                      end
                  module Provide_hash :
                    functor
                      (Elt : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 node -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          Ppx_hash_lib.Std.Hash.state ->
                          t -> Ppx_hash_lib.Std.Hash.state
                        val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                      end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              val hash : t -> Core_kernel__.Import.int
              val compare : t -> t -> Core_kernel__.Import.int
              val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
              module Table :
                sig
                  type key = t
                  type ('a, 'b) hashtbl =
                      ('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
                  type 'b t = (key, 'b) hashtbl
                  val sexp_of_t :
                    ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                  type ('a, 'b) t_ = 'b t
                  type 'a key_ = key
                  val hashable :
                    key Core_kernel__.Core_hashtbl_intf.Hashable.t
                  val invariant :
                    'Base__.Invariant_intf.inv ->
                    'a t Base__.Invariant_intf.inv
                  val create :
                    (key, 'b, unit -> 'b t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_key of key | `Ok of 'b t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_report_all_dups :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_or_error :
                    (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_exn :
                    (key, 'b, (key * 'b) list -> 'b t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_multi :
                    (key, 'b list, (key * 'b) list -> 'b list t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_mapped :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_with_key :
                    (key, 'r,
                     get_key:('-> key) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_with_key_or_error :
                    (key, 'r,
                     get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_with_key_exn :
                    (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val group :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     combine:('-> '-> 'b) -> 'r list -> 'b t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                  val clear : 'a t -> unit
                  val copy : 'b t -> 'b t
                  val fold :
                    'b t ->
                    init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                  val iter_keys : 'a t -> f:(key -> unit) -> unit
                  val iter : 'b t -> f:('-> unit) -> unit
                  val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
                  val iter_vals : 'b t -> f:('-> unit) -> unit
                  val existsi :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val exists : 'b t -> f:('-> bool) -> bool
                  val for_alli :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val for_all : 'b t -> f:('-> bool) -> bool
                  val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
                  val count : 'b t -> f:('-> bool) -> int
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val mem : 'a t -> key -> bool
                  val remove : 'a t -> key -> unit
                  val replace : 'b t -> key:key -> data:'-> unit
                  val set : 'b t -> key:key -> data:'-> unit
                  val add :
                    'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                  val add_or_error :
                    'b t -> key:key -> data:'-> unit Base__.Or_error.t
                  val add_exn : 'b t -> key:key -> data:'-> unit
                  val change :
                    'b t -> key -> f:('b option -> 'b option) -> unit
                  val update : 'b t -> key -> f:('b option -> 'b) -> unit
                  val add_multi : 'b list t -> key:key -> data:'-> unit
                  val remove_multi : 'a list t -> key -> unit
                  val map : 'b t -> f:('-> 'c) -> 'c t
                  val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                  val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                  val filter_mapi :
                    'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                  val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                  val filter : 'b t -> f:('-> bool) -> 'b t
                  val filteri :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t
                  val partition_map :
                    'b t ->
                    f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                  val partition_mapi :
                    'b t ->
                    f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                    'c t * 'd t
                  val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
                  val partitioni_tf :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                  val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
                  val find : 'b t -> key -> 'b option
                  val find_exn : 'b t -> key -> 'b
                  val find_and_call :
                    'b t ->
                    key ->
                    if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                  val find_and_remove : 'b t -> key -> 'b option
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:key ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  type 'a merge_into_action = Remove | Set_to of 'a
                  val merge_into :
                    src:'a t ->
                    dst:'b t ->
                    f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                    unit
                  val keys : 'a t -> key list
                  val data : 'b t -> 'b list
                  val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
                  val filter_inplace : 'b t -> f:('-> bool) -> unit
                  val filteri_inplace :
                    'b t -> f:(key:key -> data:'-> bool) -> unit
                  val map_inplace : 'b t -> f:('-> 'b) -> unit
                  val mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b) -> unit
                  val filter_map_inplace :
                    'b t -> f:('-> 'b option) -> unit
                  val filter_mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b option) -> unit
                  val replace_all : 'b t -> f:('-> 'b) -> unit
                  val replace_alli :
                    'b t -> f:(key:key -> data:'-> 'b) -> unit
                  val filter_replace_all :
                    'b t -> f:('-> 'b option) -> unit
                  val filter_replace_alli :
                    'b t -> f:(key:key -> data:'-> 'b option) -> unit
                  val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                  val similar :
                    'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                  val to_alist : 'b t -> (key * 'b) list
                  val validate :
                    name:(key -> string) ->
                    'Base__.Validate.check -> 'b t Base__.Validate.check
                  val incr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  val decr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  module Provide_of_sexp :
                    functor
                      (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__001_) ->
                          Sexplib.Sexp.t -> 'v_x__001_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : key Bin_prot.Type_class.t
                               val bin_read_t : key Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> key)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 key Bin_prot.Type_class.reader
                               val bin_size_t : key Bin_prot.Size.sizer
                               val bin_write_t : key Bin_prot.Write.writer
                               val bin_writer_t :
                                 key Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_t :
                          'Bin_prot.Type_class.t ->
                          'a t Bin_prot.Type_class.t
                        val bin_read_t :
                          'Bin_prot.Read.reader ->
                          'a t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          'Bin_prot.Read.reader ->
                          (Core_kernel__.Import.int -> 'a t)
                          Bin_prot.Read.reader
                        val bin_reader_t :
                          'Bin_prot.Type_class.reader ->
                          'a t Bin_prot.Type_class.reader
                        val bin_size_t :
                          'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                        val bin_write_t :
                          'Bin_prot.Write.writer ->
                          'a t Bin_prot.Write.writer
                        val bin_writer_t :
                          'Bin_prot.Type_class.writer ->
                          'a t Bin_prot.Type_class.writer
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                      end
                  val t_of_sexp :
                    (Sexplib.Sexp.t -> 'v_x__002_) ->
                    Sexplib.Sexp.t -> 'v_x__002_ t
                end
              module Hash_set :
                sig
                  type elt = t
                  type t = elt Core_kernel__.Hash_set.t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type 'a t_ = t
                  type 'a elt_ = elt
                  val create :
                    ('a, unit -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_hashable
                  val of_list :
                    ('a, elt list -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_hashable
                  module Provide_of_sexp :
                    functor
                      (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (X : sig
                             val bin_t : elt Bin_prot.Type_class.t
                             val bin_read_t : elt Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> elt)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               elt Bin_prot.Type_class.reader
                             val bin_size_t : elt Bin_prot.Size.sizer
                             val bin_write_t : elt Bin_prot.Write.writer
                             val bin_writer_t :
                               elt Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end->
                      sig
                        val bin_t : t Bin_prot.Type_class.t
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          (Core_kernel__.Import.int -> t)
                          Bin_prot.Read.reader
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_shape_t : Bin_prot.Shape.t
                      end
                  val t_of_sexp : Sexplib.Sexp.t -> t
                end
              module Hash_queue :
                sig
                  module Key :
                    sig
                      type t = node
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                      val compare : t -> t -> int
                      val hash : t -> int
                    end
                  type 'a t
                  val sexp_of_t :
                    ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val iter : 'a t -> f:('-> unit) -> unit
                  val fold :
                    'a t ->
                    init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                  val fold_result :
                    'a t ->
                    init:'accum ->
                    f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val fold_until :
                    'a t ->
                    init:'accum ->
                    f:('accum ->
                       '->
                       ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                    ('accum, 'stop)
                    Base.Container_intf.Finished_or_stopped_early.t
                  val exists : 'a t -> f:('-> bool) -> bool
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    'a t -> f:('-> 'sum) -> 'sum
                  val find : 'a t -> f:('-> bool) -> 'a option
                  val find_map : 'a t -> f:('-> 'b option) -> 'b option
                  val to_list : 'a t -> 'a list
                  val to_array : 'a t -> 'a array
                  val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
                  val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
                  val invariant : 'a t -> Core_kernel__.Import.unit
                  val create :
                    ?growth_allowed:Core_kernel__.Import.bool ->
                    ?size:Core_kernel__.Import.int ->
                    Core_kernel__.Import.unit -> 'a t
                  val clear : 'a t -> Core_kernel__.Import.unit
                  val mem : 'a t -> node -> Core_kernel__.Import.bool
                  val lookup : 'a t -> node -> 'Core_kernel__.Import.option
                  val lookup_exn : 'a t -> node -> 'a
                  val enqueue :
                    'a t -> node -> '-> [ `Key_already_present | `Ok ]
                  val enqueue_exn :
                    'a t -> node -> '-> Core_kernel__.Import.unit
                  val lookup_and_move_to_back :
                    'a t -> node -> 'Core_kernel__.Import.option
                  val lookup_and_move_to_back_exn : 'a t -> node -> 'a
                  val first : 'a t -> 'Core_kernel__.Import.option
                  val first_with_key :
                    'a t -> (node * 'a) Core_kernel__.Import.option
                  val keys : 'a t -> node Core_kernel__.Import.list
                  val dequeue : 'a t -> 'Core_kernel__.Import.option
                  val dequeue_exn : 'a t -> 'a
                  val dequeue_with_key :
                    'a t -> (node * 'a) Core_kernel__.Import.option
                  val dequeue_with_key_exn : 'a t -> node * 'a
                  val dequeue_all :
                    'a t ->
                    f:('-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val remove : 'a t -> node -> [ `No_such_key | `Ok ]
                  val remove_exn : 'a t -> node -> Core_kernel__.Import.unit
                  val replace : 'a t -> node -> '-> [ `No_such_key | `Ok ]
                  val replace_exn :
                    'a t -> node -> '-> Core_kernel__.Import.unit
                  val iteri :
                    'a t ->
                    f:(key:node -> data:'-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val foldi :
                    'a t ->
                    init:'-> f:('-> key:node -> data:'-> 'b) -> 'b
                end
            end
          module Edge :
            sig
              type t = edge
              type node = Node.t
              type graph = Node.graph
              type label
              val create : node -> node -> label -> t
              val label : t -> label
              val src : t -> node
              val dst : t -> node
              val mem : t -> graph -> bool
              val insert : t -> graph -> graph
              val update : t -> label -> graph -> graph
              val remove : t -> graph -> graph
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val min : t -> t -> t
              val max : t -> t -> t
              val ascending : t -> t -> int
              val descending : t -> t -> int
              val between : t -> low:t -> high:t -> bool
              val clamp_exn : t -> min:t -> max:t -> t
              val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
              type comparator_witness
              val comparator :
                (t, comparator_witness) Base__.Comparator.comparator
              val validate_lbound :
                min:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_ubound :
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              val validate_bound :
                min:t Base__.Maybe_bound.t ->
                max:t Base__.Maybe_bound.t -> t Base__.Validate.check
              module Replace_polymorphic_compare :
                sig
                  val ( >= ) : t -> t -> bool
                  val ( <= ) : t -> t -> bool
                  val ( = ) : t -> t -> bool
                  val ( > ) : t -> t -> bool
                  val ( < ) : t -> t -> bool
                  val ( <> ) : t -> t -> bool
                  val equal : t -> t -> bool
                  val compare : t -> t -> int
                  val min : t -> t -> t
                  val max : t -> t -> t
                end
              module Map :
                sig
                  module Key :
                    sig
                      type t = edge
                      val t_of_sexp : Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      type comparator_witness = comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type 'a t =
                          (edge, 'a, comparator_witness)
                          Core_kernel__.Core_map_intf.Tree.t
                      val empty : 'a t
                      val singleton : edge -> '-> 'a t
                      val of_alist :
                        (edge * 'a) list ->
                        [ `Duplicate_key of edge | `Ok of 'a t ]
                      val of_alist_or_error :
                        (edge * 'a) list -> 'a t Base__.Or_error.t
                      val of_alist_exn : (edge * 'a) list -> 'a t
                      val of_alist_multi : (edge * 'a) list -> 'a list t
                      val of_alist_fold :
                        (edge * 'a) list ->
                        init:'-> f:('-> '-> 'b) -> 'b t
                      val of_alist_reduce :
                        (edge * 'a) list -> f:('-> '-> 'a) -> 'a t
                      val of_sorted_array :
                        (edge * 'a) array -> 'a t Base__.Or_error.t
                      val of_sorted_array_unchecked :
                        (edge * 'a) array -> 'a t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> edge * 'a) -> 'a t
                      val of_iteri :
                        iteri:(f:(key:edge -> data:'-> unit) -> unit) ->
                        [ `Duplicate_key of edge | `Ok of 'v t ]
                      val of_tree : 'a t -> 'a t
                      val of_hashtbl_exn :
                        (edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                      val gen :
                        edge Core_kernel__.Quickcheck.Generator.t ->
                        'Core_kernel__.Quickcheck.Generator.t ->
                        'a t Core_kernel__.Quickcheck.Generator.t
                      val invariants : 'a t -> bool
                      val is_empty : 'a t -> bool
                      val length : 'a t -> int
                      val add : 'a t -> key:edge -> data:'-> 'a t
                      val add_multi :
                        'a list t -> key:edge -> data:'-> 'a list t
                      val remove_multi : 'a list t -> edge -> 'a list t
                      val change :
                        'a t -> edge -> f:('a option -> 'a option) -> 'a t
                      val update :
                        'a t -> edge -> f:('a option -> 'a) -> 'a t
                      val find : 'a t -> edge -> 'a option
                      val find_exn : 'a t -> edge -> 'a
                      val remove : 'a t -> edge -> 'a t
                      val mem : 'a t -> edge -> bool
                      val iter_keys : 'a t -> f:(edge -> unit) -> unit
                      val iter : 'a t -> f:('-> unit) -> unit
                      val iteri :
                        'a t -> f:(key:edge -> data:'-> unit) -> unit
                      val iter2 :
                        'a t ->
                        'b t ->
                        f:(key:edge ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           unit) ->
                        unit
                      val map : 'a t -> f:('-> 'b) -> 'b t
                      val mapi :
                        'a t -> f:(key:edge -> data:'-> 'b) -> 'b t
                      val fold :
                        'a t ->
                        init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                      val fold_right :
                        'a t ->
                        init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                      val fold2 :
                        'a t ->
                        'b t ->
                        init:'->
                        f:(key:edge ->
                           data:[ `Both of 'a * 'b
                                | `Left of 'a
                                | `Right of 'b ] ->
                           '-> 'c) ->
                        'c
                      val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
                      val filter : 'a t -> f:('-> bool) -> 'a t
                      val filteri :
                        'a t -> f:(key:edge -> data:'-> bool) -> 'a t
                      val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                      val filter_mapi :
                        'a t -> f:(key:edge -> data:'-> 'b option) -> 'b t
                      val partition_mapi :
                        'a t ->
                        f:(key:edge -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                        'b t * 'c t
                      val partition_map :
                        'a t ->
                        f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                      val partitioni_tf :
                        'a t ->
                        f:(key:edge -> data:'-> bool) -> 'a t * 'a t
                      val partition_tf :
                        'a t -> f:('-> bool) -> 'a t * 'a t
                      val compare_direct :
                        ('-> '-> int) -> 'a t -> 'a t -> int
                      val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                      val keys : 'a t -> edge list
                      val data : 'a t -> 'a list
                      val to_alist :
                        ?key_order:[ `Decreasing | `Increasing ] ->
                        'a t -> (edge * 'a) list
                      val validate :
                        name:(edge -> string) ->
                        'Base__.Validate.check ->
                        'a t Base__.Validate.check
                      val merge :
                        'a t ->
                        'b t ->
                        f:(key:edge ->
                           [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                           'c option) ->
                        'c t
                      val symmetric_diff :
                        'a t ->
                        'a t ->
                        data_equal:('-> '-> bool) ->
                        (edge, 'a)
                        Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                        Base__.Sequence.t
                      val min_elt : 'a t -> (edge * 'a) option
                      val min_elt_exn : 'a t -> edge * 'a
                      val max_elt : 'a t -> (edge * 'a) option
                      val max_elt_exn : 'a t -> edge * 'a
                      val for_all : 'a t -> f:('-> bool) -> bool
                      val for_alli :
                        'a t -> f:(key:edge -> data:'-> bool) -> bool
                      val exists : 'a t -> f:('-> bool) -> bool
                      val existsi :
                        'a t -> f:(key:edge -> data:'-> bool) -> bool
                      val count : 'a t -> f:('-> bool) -> int
                      val counti :
                        'a t -> f:(key:edge -> data:'-> bool) -> int
                      val split :
                        'a t -> edge -> 'a t * (edge * 'a) option * 'a t
                      val append :
                        lower_part:'a t ->
                        upper_part:'a t ->
                        [ `Ok of 'a t | `Overlapping_key_ranges ]
                      val subrange :
                        'a t ->
                        lower_bound:edge Base__.Maybe_bound.t ->
                        upper_bound:edge Base__.Maybe_bound.t -> 'a t
                      val fold_range_inclusive :
                        'a t ->
                        min:edge ->
                        max:edge ->
                        init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                      val range_to_alist :
                        'a t -> min:edge -> max:edge -> (edge * 'a) list
                      val closest_key :
                        'a t ->
                        [ `Greater_or_equal_to
                        | `Greater_than
                        | `Less_or_equal_to
                        | `Less_than ] -> edge -> (edge * 'a) option
                      val nth : 'a t -> int -> (edge * 'a) option
                      val nth_exn : 'a t -> int -> edge * 'a
                      val rank : 'a t -> edge -> int option
                      val to_tree : 'a t -> 'a t
                      val to_sequence :
                        ?order:[ `Decreasing_key | `Increasing_key ] ->
                        ?keys_greater_or_equal_to:edge ->
                        ?keys_less_or_equal_to:edge ->
                        'a t -> (edge * 'a) Base__.Sequence.t
                      val obs :
                        edge Core_kernel__.Quickcheck.Observer.t ->
                        'Core_kernel__.Quickcheck.Observer.t ->
                        'v t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        edge Core_kernel__.Quickcheck.Shrinker.t ->
                        'Core_kernel__.Quickcheck.Shrinker.t ->
                        'v t Core_kernel__.Quickcheck.Shrinker.t
                      module Provide_of_sexp :
                        functor
                          (K : sig val t_of_sexp : Sexplib.Sexp.t -> edge end->
                          sig
                            val t_of_sexp :
                              (Sexplib.Sexp.t -> 'v_x__017_) ->
                              Sexplib.Sexp.t -> 'v_x__017_ t
                          end
                      val t_of_sexp :
                        (Base__.Sexplib.Sexp.t -> 'a) ->
                        Base__.Sexplib.Sexp.t -> 'a t
                      val sexp_of_t :
                        ('-> Base__.Sexplib.Sexp.t) ->
                        'a t -> Base__.Sexplib.Sexp.t
                    end
                  type 'a t =
                      (edge, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Map.t
                  val compare :
                    ('-> '-> Core_kernel__.Import.int) ->
                    'a t -> 'a t -> Core_kernel__.Import.int
                  val empty : 'a t
                  val singleton : edge -> '-> 'a t
                  val of_alist :
                    (edge * 'a) list ->
                    [ `Duplicate_key of edge | `Ok of 'a t ]
                  val of_alist_or_error :
                    (edge * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (edge * 'a) list -> 'a t
                  val of_alist_multi : (edge * 'a) list -> 'a list t
                  val of_alist_fold :
                    (edge * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (edge * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (edge * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (edge * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> edge * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:edge -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of edge | `Ok of 'v t ]
                  val of_tree : 'Tree.t -> 'a t
                  val of_hashtbl_exn :
                    (edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    edge Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:edge -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:edge -> data:'-> 'a list t
                  val remove_multi : 'a list t -> edge -> 'a list t
                  val change :
                    'a t -> edge -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> edge -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> edge -> 'a option
                  val find_exn : 'a t -> edge -> 'a
                  val remove : 'a t -> edge -> 'a t
                  val mem : 'a t -> edge -> bool
                  val iter_keys : 'a t -> f:(edge -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri : 'a t -> f:(key:edge -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:edge ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:edge -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:edge ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:edge -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:edge -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:edge -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:edge -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> edge list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (edge * 'a) list
                  val validate :
                    name:(edge -> string) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:edge ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (edge, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (edge * 'a) option
                  val min_elt_exn : 'a t -> edge * 'a
                  val max_elt : 'a t -> (edge * 'a) option
                  val max_elt_exn : 'a t -> edge * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:edge -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:edge -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti : 'a t -> f:(key:edge -> data:'-> bool) -> int
                  val split :
                    'a t -> edge -> 'a t * (edge * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:edge Base__.Maybe_bound.t ->
                    upper_bound:edge Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:edge ->
                    max:edge ->
                    init:'-> f:(key:edge -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:edge -> max:edge -> (edge * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> edge -> (edge * 'a) option
                  val nth : 'a t -> int -> (edge * 'a) option
                  val nth_exn : 'a t -> int -> edge * 'a
                  val rank : 'a t -> edge -> int option
                  val to_tree : 'a t -> 'Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:edge ->
                    ?keys_less_or_equal_to:edge ->
                    'a t -> (edge * 'a) Base__.Sequence.t
                  val obs :
                    edge Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    edge Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (Key : sig val t_of_sexp : Sexplib.Sexp.t -> edge end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__018_) ->
                          Sexplib.Sexp.t -> 'v_x__018_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : edge Bin_prot.Type_class.t
                               val bin_read_t : edge Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> edge)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 edge Bin_prot.Type_class.reader
                               val bin_size_t : edge Bin_prot.Size.sizer
                               val bin_write_t : edge Bin_prot.Write.writer
                               val bin_writer_t :
                                 edge Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                        val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                        val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                        val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                        val __bin_read_t__ :
                          ('a, int -> 'a t) Bin_prot.Read.reader1
                        val bin_writer_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.writer
                        val bin_reader_t :
                          ('a, 'a t) Bin_prot.Type_class.S1.reader
                        val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                      end
                  module Provide_hash :
                    functor
                      (Key : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 edge -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          (Ppx_hash_lib.Std.Hash.state ->
                           '-> Ppx_hash_lib.Std.Hash.state) ->
                          Ppx_hash_lib.Std.Hash.state ->
                          'a t -> Ppx_hash_lib.Std.Hash.state
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              module Set :
                sig
                  module Elt :
                    sig
                      type t = edge
                      val t_of_sexp : Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Sexplib.Sexp.t
                      type comparator_witness = Map.Key.comparator_witness
                      val comparator :
                        (t, comparator_witness)
                        Core_kernel__.Comparator.comparator
                    end
                  module Tree :
                    sig
                      type t =
                          (edge, comparator_witness)
                          Core_kernel__.Core_set_intf.Tree.t
                      val compare : t -> t -> Core_kernel__.Import.int
                      val length : t -> int
                      val is_empty : t -> bool
                      val iter : t -> f:(edge -> unit) -> unit
                      val fold :
                        t ->
                        init:'accum -> f:('accum -> edge -> 'accum) -> 'accum
                      val fold_result :
                        t ->
                        init:'accum ->
                        f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
                        ('accum, 'e) Base__.Result.t
                      val exists : t -> f:(edge -> bool) -> bool
                      val for_all : t -> f:(edge -> bool) -> bool
                      val count : t -> f:(edge -> bool) -> int
                      val sum :
                        (module Base__.Commutative_group.S with type t = 'sum) ->
                        t -> f:(edge -> 'sum) -> 'sum
                      val find : t -> f:(edge -> bool) -> edge option
                      val find_map : t -> f:(edge -> 'a option) -> 'a option
                      val to_list : t -> edge list
                      val to_array : t -> edge array
                      val invariants : t -> bool
                      val mem : t -> edge -> bool
                      val add : t -> edge -> t
                      val remove : t -> edge -> t
                      val union : t -> t -> t
                      val inter : t -> t -> t
                      val diff : t -> t -> t
                      val symmetric_diff :
                        t ->
                        t -> (edge, edge) Base__.Either.t Base__.Sequence.t
                      val compare_direct : t -> t -> int
                      val equal : t -> t -> bool
                      val is_subset : t -> of_:t -> bool
                      val subset : t -> t -> bool
                      val fold_until :
                        t ->
                        init:'->
                        f:('->
                           edge ->
                           ('b, 'stop)
                           Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                        ('b, 'stop)
                        Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                      val fold_right :
                        t -> init:'-> f:(edge -> '-> 'b) -> 'b
                      val iter2 :
                        t ->
                        t ->
                        f:([ `Both of edge * edge
                           | `Left of edge
                           | `Right of edge ] -> unit) ->
                        unit
                      val filter : t -> f:(edge -> bool) -> t
                      val partition_tf : t -> f:(edge -> bool) -> t * t
                      val elements : t -> edge list
                      val min_elt : t -> edge option
                      val min_elt_exn : t -> edge
                      val max_elt : t -> edge option
                      val max_elt_exn : t -> edge
                      val choose : t -> edge option
                      val choose_exn : t -> edge
                      val split : t -> edge -> t * edge option * t
                      val group_by :
                        t -> equiv:(edge -> edge -> bool) -> t list
                      val find_exn : t -> f:(edge -> bool) -> edge
                      val find_index : t -> int -> edge option
                      val nth : t -> int -> edge option
                      val remove_index : t -> int -> t
                      val to_tree : t -> t
                      val to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:edge ->
                        ?less_or_equal_to:edge -> t -> edge Base__.Sequence.t
                      val merge_to_sequence :
                        ?order:[ `Decreasing | `Increasing ] ->
                        ?greater_or_equal_to:edge ->
                        ?less_or_equal_to:edge ->
                        t ->
                        t ->
                        (edge, edge)
                        Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                        Base__.Sequence.t
                      val to_map :
                        t ->
                        f:(edge -> 'data) ->
                        (edge, 'data, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t
                      val obs :
                        edge Core_kernel__.Quickcheck.Observer.t ->
                        t Core_kernel__.Quickcheck.Observer.t
                      val shrinker :
                        edge Core_kernel__.Quickcheck.Shrinker.t ->
                        t Core_kernel__.Quickcheck.Shrinker.t
                      val empty : t
                      val singleton : edge -> t
                      val union_list : t list -> t
                      val of_list : edge list -> t
                      val of_array : edge array -> t
                      val of_sorted_array : edge array -> t Base__.Or_error.t
                      val of_sorted_array_unchecked : edge array -> t
                      val of_increasing_iterator_unchecked :
                        len:int -> f:(int -> edge) -> t
                      val stable_dedup_list : edge list -> edge list
                      val map :
                        ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                        f:('-> edge) -> t
                      val filter_map :
                        ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                        f:('-> edge option) -> t
                      val of_tree : t -> t
                      val of_hash_set : edge Core_kernel__.Hash_set.t -> t
                      val of_hashtbl_keys :
                        (edge, 'a) Core_kernel__.Core_hashtbl.t -> t
                      val of_map_keys :
                        (edge, 'a, comparator_witness)
                        Core_kernel__.Core_set_intf.Map.t -> t
                      val gen :
                        edge Core_kernel__.Quickcheck.Generator.t ->
                        t Core_kernel__.Quickcheck.Generator.t
                      module Provide_of_sexp :
                        functor
                          (Elt : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> edge
                                 end->
                          sig val t_of_sexp : Sexplib.Sexp.t -> t end
                      val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                    end
                  type t = (edge, comparator_witness) Base.Set.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(edge -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> edge -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(edge -> bool) -> bool
                  val for_all : t -> f:(edge -> bool) -> bool
                  val count : t -> f:(edge -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(edge -> 'sum) -> 'sum
                  val find : t -> f:(edge -> bool) -> edge option
                  val find_map : t -> f:(edge -> 'a option) -> 'a option
                  val to_list : t -> edge list
                  val to_array : t -> edge array
                  val invariants : t -> bool
                  val mem : t -> edge -> bool
                  val add : t -> edge -> t
                  val remove : t -> edge -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t -> t -> (edge, edge) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       edge ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right : t -> init:'-> f:(edge -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of edge * edge
                       | `Left of edge
                       | `Right of edge ] -> unit) ->
                    unit
                  val filter : t -> f:(edge -> bool) -> t
                  val partition_tf : t -> f:(edge -> bool) -> t * t
                  val elements : t -> edge list
                  val min_elt : t -> edge option
                  val min_elt_exn : t -> edge
                  val max_elt : t -> edge option
                  val max_elt_exn : t -> edge
                  val choose : t -> edge option
                  val choose_exn : t -> edge
                  val split : t -> edge -> t * edge option * t
                  val group_by : t -> equiv:(edge -> edge -> bool) -> t list
                  val find_exn : t -> f:(edge -> bool) -> edge
                  val find_index : t -> int -> edge option
                  val nth : t -> int -> edge option
                  val remove_index : t -> int -> t
                  val to_tree : t -> Tree.t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:edge ->
                    ?less_or_equal_to:edge -> t -> edge Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:edge ->
                    ?less_or_equal_to:edge ->
                    t ->
                    t ->
                    (edge, edge)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(edge -> 'data) ->
                    (edge, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    edge Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    edge Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : edge -> t
                  val union_list : t list -> t
                  val of_list : edge list -> t
                  val of_array : edge array -> t
                  val of_sorted_array : edge array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : edge array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> edge) -> t
                  val stable_dedup_list : edge list -> edge list
                  val map : ('a, 'b) Base.Set.t -> f:('-> edge) -> t
                  val filter_map :
                    ('a, 'b) Base.Set.t -> f:('-> edge option) -> t
                  val of_tree : Tree.t -> t
                  val of_hash_set : edge Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (edge, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (edge, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    edge Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> edge end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (Elt : sig
                               val bin_t : edge Bin_prot.Type_class.t
                               val bin_read_t : edge Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> edge)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 edge Bin_prot.Type_class.reader
                               val bin_size_t : edge Bin_prot.Size.sizer
                               val bin_write_t : edge Bin_prot.Write.writer
                               val bin_writer_t :
                                 edge Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                        val bin_shape_t : Bin_prot.Shape.t
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_t : t Bin_prot.Type_class.t
                      end
                  module Provide_hash :
                    functor
                      (Elt : sig
                               val hash_fold_t :
                                 Base__.Hash.state ->
                                 edge -> Base__.Hash.state
                             end->
                      sig
                        val hash_fold_t :
                          Ppx_hash_lib.Std.Hash.state ->
                          t -> Ppx_hash_lib.Std.Hash.state
                        val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                      end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              val hash : t -> Core_kernel__.Import.int
              val compare : t -> t -> Core_kernel__.Import.int
              val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
              module Table :
                sig
                  type key = t
                  type ('a, 'b) hashtbl = ('a, 'b) Node.Table.hashtbl
                  type 'b t = (key, 'b) hashtbl
                  val sexp_of_t :
                    ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                  type ('a, 'b) t_ = 'b t
                  type 'a key_ = key
                  val hashable :
                    key Core_kernel__.Core_hashtbl_intf.Hashable.t
                  val invariant :
                    'Base__.Invariant_intf.inv ->
                    'a t Base__.Invariant_intf.inv
                  val create :
                    (key, 'b, unit -> 'b t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_key of key | `Ok of 'b t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_report_all_dups :
                    (key, 'b,
                     (key * 'b) list ->
                     [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_or_error :
                    (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_exn :
                    (key, 'b, (key * 'b) list -> 'b t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val of_alist_multi :
                    (key, 'b list, (key * 'b) list -> 'b list t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_mapped :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_with_key :
                    (key, 'r,
                     get_key:('-> key) ->
                     'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_with_key_or_error :
                    (key, 'r,
                     get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val create_with_key_exn :
                    (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val group :
                    (key, 'b,
                     get_key:('-> key) ->
                     get_data:('-> 'b) ->
                     combine:('-> '-> 'b) -> 'r list -> 'b t)
                    Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                  val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                  val clear : 'a t -> unit
                  val copy : 'b t -> 'b t
                  val fold :
                    'b t ->
                    init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                  val iter_keys : 'a t -> f:(key -> unit) -> unit
                  val iter : 'b t -> f:('-> unit) -> unit
                  val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
                  val iter_vals : 'b t -> f:('-> unit) -> unit
                  val existsi :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val exists : 'b t -> f:('-> bool) -> bool
                  val for_alli :
                    'b t -> f:(key:key -> data:'-> bool) -> bool
                  val for_all : 'b t -> f:('-> bool) -> bool
                  val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
                  val count : 'b t -> f:('-> bool) -> int
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val mem : 'a t -> key -> bool
                  val remove : 'a t -> key -> unit
                  val replace : 'b t -> key:key -> data:'-> unit
                  val set : 'b t -> key:key -> data:'-> unit
                  val add :
                    'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                  val add_or_error :
                    'b t -> key:key -> data:'-> unit Base__.Or_error.t
                  val add_exn : 'b t -> key:key -> data:'-> unit
                  val change :
                    'b t -> key -> f:('b option -> 'b option) -> unit
                  val update : 'b t -> key -> f:('b option -> 'b) -> unit
                  val add_multi : 'b list t -> key:key -> data:'-> unit
                  val remove_multi : 'a list t -> key -> unit
                  val map : 'b t -> f:('-> 'c) -> 'c t
                  val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                  val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                  val filter_mapi :
                    'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                  val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                  val filter : 'b t -> f:('-> bool) -> 'b t
                  val filteri :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t
                  val partition_map :
                    'b t ->
                    f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                  val partition_mapi :
                    'b t ->
                    f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                    'c t * 'd t
                  val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
                  val partitioni_tf :
                    'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                  val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
                  val find : 'b t -> key -> 'b option
                  val find_exn : 'b t -> key -> 'b
                  val find_and_call :
                    'b t ->
                    key ->
                    if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                  val find_and_remove : 'b t -> key -> 'b option
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:key ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  type 'a merge_into_action = Remove | Set_to of 'a
                  val merge_into :
                    src:'a t ->
                    dst:'b t ->
                    f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                    unit
                  val keys : 'a t -> key list
                  val data : 'b t -> 'b list
                  val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
                  val filter_inplace : 'b t -> f:('-> bool) -> unit
                  val filteri_inplace :
                    'b t -> f:(key:key -> data:'-> bool) -> unit
                  val map_inplace : 'b t -> f:('-> 'b) -> unit
                  val mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b) -> unit
                  val filter_map_inplace :
                    'b t -> f:('-> 'b option) -> unit
                  val filter_mapi_inplace :
                    'b t -> f:(key:key -> data:'-> 'b option) -> unit
                  val replace_all : 'b t -> f:('-> 'b) -> unit
                  val replace_alli :
                    'b t -> f:(key:key -> data:'-> 'b) -> unit
                  val filter_replace_all :
                    'b t -> f:('-> 'b option) -> unit
                  val filter_replace_alli :
                    'b t -> f:(key:key -> data:'-> 'b option) -> unit
                  val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                  val similar :
                    'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                  val to_alist : 'b t -> (key * 'b) list
                  val validate :
                    name:(key -> string) ->
                    'Base__.Validate.check -> 'b t Base__.Validate.check
                  val incr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  val decr :
                    ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                  module Provide_of_sexp :
                    functor
                      (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__001_) ->
                          Sexplib.Sexp.t -> 'v_x__001_ t
                      end
                  module Provide_bin_io :
                    functor
                      (Key : sig
                               val bin_t : key Bin_prot.Type_class.t
                               val bin_read_t : key Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> key)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 key Bin_prot.Type_class.reader
                               val bin_size_t : key Bin_prot.Size.sizer
                               val bin_write_t : key Bin_prot.Write.writer
                               val bin_writer_t :
                                 key Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                      sig
                        val bin_t :
                          'Bin_prot.Type_class.t ->
                          'a t Bin_prot.Type_class.t
                        val bin_read_t :
                          'Bin_prot.Read.reader ->
                          'a t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          'Bin_prot.Read.reader ->
                          (Core_kernel__.Import.int -> 'a t)
                          Bin_prot.Read.reader
                        val bin_reader_t :
                          'Bin_prot.Type_class.reader ->
                          'a t Bin_prot.Type_class.reader
                        val bin_size_t :
                          'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                        val bin_write_t :
                          'Bin_prot.Write.writer ->
                          'a t Bin_prot.Write.writer
                        val bin_writer_t :
                          'Bin_prot.Type_class.writer ->
                          'a t Bin_prot.Type_class.writer
                        val bin_shape_t :
                          Bin_prot.Shape.t -> Bin_prot.Shape.t
                      end
                  val t_of_sexp :
                    (Sexplib.Sexp.t -> 'v_x__002_) ->
                    Sexplib.Sexp.t -> 'v_x__002_ t
                end
              module Hash_set :
                sig
                  type elt = t
                  type t = elt Core_kernel__.Hash_set.t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type 'a t_ = t
                  type 'a elt_ = elt
                  val create :
                    ('a, unit -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_hashable
                  val of_list :
                    ('a, elt list -> t)
                    Core_kernel__.Hash_set_intf.create_options_without_hashable
                  module Provide_of_sexp :
                    functor
                      (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  module Provide_bin_io :
                    functor
                      (X : sig
                             val bin_t : elt Bin_prot.Type_class.t
                             val bin_read_t : elt Bin_prot.Read.reader
                             val __bin_read_t__ :
                               (Core_kernel__.Import.int -> elt)
                               Bin_prot.Read.reader
                             val bin_reader_t :
                               elt Bin_prot.Type_class.reader
                             val bin_size_t : elt Bin_prot.Size.sizer
                             val bin_write_t : elt Bin_prot.Write.writer
                             val bin_writer_t :
                               elt Bin_prot.Type_class.writer
                             val bin_shape_t : Bin_prot.Shape.t
                           end->
                      sig
                        val bin_t : t Bin_prot.Type_class.t
                        val bin_read_t : t Bin_prot.Read.reader
                        val __bin_read_t__ :
                          (Core_kernel__.Import.int -> t)
                          Bin_prot.Read.reader
                        val bin_reader_t : t Bin_prot.Type_class.reader
                        val bin_size_t : t Bin_prot.Size.sizer
                        val bin_write_t : t Bin_prot.Write.writer
                        val bin_writer_t : t Bin_prot.Type_class.writer
                        val bin_shape_t : Bin_prot.Shape.t
                      end
                  val t_of_sexp : Sexplib.Sexp.t -> t
                end
              module Hash_queue :
                sig
                  module Key :
                    sig
                      type t = edge
                      val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                      val compare : t -> t -> int
                      val hash : t -> int
                    end
                  type 'a t
                  val sexp_of_t :
                    ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                  val length : 'a t -> int
                  val is_empty : 'a t -> bool
                  val iter : 'a t -> f:('-> unit) -> unit
                  val fold :
                    'a t ->
                    init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                  val fold_result :
                    'a t ->
                    init:'accum ->
                    f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val fold_until :
                    'a t ->
                    init:'accum ->
                    f:('accum ->
                       '->
                       ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                    ('accum, 'stop)
                    Base.Container_intf.Finished_or_stopped_early.t
                  val exists : 'a t -> f:('-> bool) -> bool
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    'a t -> f:('-> 'sum) -> 'sum
                  val find : 'a t -> f:('-> bool) -> 'a option
                  val find_map : 'a t -> f:('-> 'b option) -> 'b option
                  val to_list : 'a t -> 'a list
                  val to_array : 'a t -> 'a array
                  val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
                  val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
                  val invariant : 'a t -> Core_kernel__.Import.unit
                  val create :
                    ?growth_allowed:Core_kernel__.Import.bool ->
                    ?size:Core_kernel__.Import.int ->
                    Core_kernel__.Import.unit -> 'a t
                  val clear : 'a t -> Core_kernel__.Import.unit
                  val mem : 'a t -> edge -> Core_kernel__.Import.bool
                  val lookup : 'a t -> edge -> 'Core_kernel__.Import.option
                  val lookup_exn : 'a t -> edge -> 'a
                  val enqueue :
                    'a t -> edge -> '-> [ `Key_already_present | `Ok ]
                  val enqueue_exn :
                    'a t -> edge -> '-> Core_kernel__.Import.unit
                  val lookup_and_move_to_back :
                    'a t -> edge -> 'Core_kernel__.Import.option
                  val lookup_and_move_to_back_exn : 'a t -> edge -> 'a
                  val first : 'a t -> 'Core_kernel__.Import.option
                  val first_with_key :
                    'a t -> (edge * 'a) Core_kernel__.Import.option
                  val keys : 'a t -> edge Core_kernel__.Import.list
                  val dequeue : 'a t -> 'Core_kernel__.Import.option
                  val dequeue_exn : 'a t -> 'a
                  val dequeue_with_key :
                    'a t -> (edge * 'a) Core_kernel__.Import.option
                  val dequeue_with_key_exn : 'a t -> edge * 'a
                  val dequeue_all :
                    'a t ->
                    f:('-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val remove : 'a t -> edge -> [ `No_such_key | `Ok ]
                  val remove_exn : 'a t -> edge -> Core_kernel__.Import.unit
                  val replace : 'a t -> edge -> '-> [ `No_such_key | `Ok ]
                  val replace_exn :
                    'a t -> edge -> '-> Core_kernel__.Import.unit
                  val iteri :
                    'a t ->
                    f:(key:edge -> data:'-> Core_kernel__.Import.unit) ->
                    Core_kernel__.Import.unit
                  val foldi :
                    'a t ->
                    init:'-> f:('-> key:edge -> data:'-> 'b) -> 'b
                end
            end
          val empty : Graphlib.Std.Graph.t
          val nodes :
            Graphlib.Std.Graph.t -> Graphlib.Std.Graph.node Regular.Std.seq
          val edges :
            Graphlib.Std.Graph.t -> Graphlib.Std.Graph.edge Regular.Std.seq
          val is_directed : bool
          val number_of_edges : Graphlib.Std.Graph.t -> int
          val number_of_nodes : Graphlib.Std.Graph.t -> int
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val comparator :
            (t, comparator_witness) Base__.Comparator.comparator
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          module Map :
            sig
              module Key :
                sig
                  type t = Edge.graph
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> string) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__017_) ->
                          Sexplib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Core_map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn :
                (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> string) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a)
                Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__018_) ->
                      Sexplib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : Key.t Bin_prot.Type_class.t
                           val bin_read_t : Key.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Key.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Key.t Bin_prot.Type_class.reader
                           val bin_size_t : Key.t Bin_prot.Size.sizer
                           val bin_write_t : Key.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Key.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Key.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Sexplib.Sexp.t -> 'a) ->
                Base__.Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Sexplib.Sexp.t) ->
                'a t -> Base__.Sexplib.Sexp.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = Edge.graph
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Core_set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t option) -> t
                  val of_tree : t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              type t = (Elt.t, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t ->
                   ('b, 'stop)
                   Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                ('b, 'stop)
                Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t)
                Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys :
                (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : Elt.t Bin_prot.Type_class.t
                           val bin_read_t : Elt.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Elt.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Elt.t Bin_prot.Type_class.reader
                           val bin_size_t : Elt.t Bin_prot.Size.sizer
                           val bin_write_t : Elt.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Elt.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Elt.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Sexplib.Sexp.t
            end
          val hash : t -> Core_kernel__.Import.int
          val compare : t -> t -> Core_kernel__.Import.int
          val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl = ('a, 'b) Edge.Table.hashtbl
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val iter_vals : 'b t -> f:('-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val replace : 'b t -> key:key -> data:'-> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_or_error :
                'b t -> key:key -> data:'-> unit Base__.Or_error.t
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val replace_all : 'b t -> f:('-> 'b) -> unit
              val replace_alli : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_replace_all : 'b t -> f:('-> 'b option) -> unit
              val filter_replace_alli :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> string) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__001_) ->
                      Sexplib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'v_x__002_) ->
                Sexplib.Sexp.t -> 'v_x__002_ t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              module Provide_of_sexp :
                functor
                  (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Sexplib.Sexp.t -> t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = Hash_set.elt
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val compare : t -> t -> int
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                ('accum, 'stop)
                Base.Container_intf.Finished_or_stopped_early.t
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
              val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val keys : 'a t -> Key.t Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
              val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
            end
          val to_string : t -> string
          val str : unit -> t -> string
          val pps : unit -> t -> string
          val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
          val pp_seq :
            Format.formatter -> t Core_kernel.Std.Sequence.t -> unit
          val pp : Base__.Import.Caml.Format.formatter -> t -> unit
        end
      type ('c, 'n, 'e) graph =
          (module Graphlib.Std.Graph with type edge = 'and type node = 'and type t = 'c)
      type edge_kind = [ `Back | `Cross | `Forward | `Tree ]
      type 'a tree
      type 'a frontier
      type 'a partition
      type 'a group
      type 'a path
      type equiv
      module Tree :
        sig
          type 'a t = 'Graphlib.Std.tree
          val children : 'Graphlib.Std.Tree.t -> '-> 'Regular.Std.seq
          val parent : 'Graphlib.Std.Tree.t -> '-> 'a option
          val ancestors : 'Graphlib.Std.Tree.t -> '-> 'Regular.Std.seq
          val descendants :
            'Graphlib.Std.Tree.t -> '-> 'Regular.Std.seq
          val is_child_of : 'Graphlib.Std.Tree.t -> parent:'-> '-> bool
          val is_ancestor_of :
            'Graphlib.Std.Tree.t -> child:'-> '-> bool
          val is_descendant_of :
            'Graphlib.Std.Tree.t -> parent:'-> '-> bool
          val to_sequence : 'Graphlib.Std.Tree.t -> 'Regular.Std.seq
          val pp :
            'Regular.Std.printer ->
            'Graphlib.Std.Tree.t Regular.Std.printer
        end
      module Frontier :
        sig
          type 'a t = 'Graphlib.Std.frontier
          val enum : 'Graphlib.Std.Frontier.t -> '-> 'Regular.Std.seq
          val mem : 'Graphlib.Std.Frontier.t -> '-> '-> bool
          val to_sequence : 'Graphlib.Std.Frontier.t -> 'Regular.Std.seq
          val pp :
            'Regular.Std.printer ->
            'Graphlib.Std.Frontier.t Regular.Std.printer
        end
      module Path :
        sig
          type 'e t = 'Graphlib.Std.path
          val start : 'Graphlib.Std.Path.t -> 'e
          val finish : 'Graphlib.Std.Path.t -> 'e
          val edges : 'Graphlib.Std.Path.t -> 'Regular.Std.seq
          val edges_rev : 'Graphlib.Std.Path.t -> 'Regular.Std.seq
          val weight : 'Graphlib.Std.Path.t -> int
          val length : 'Graphlib.Std.Path.t -> int
          val pp :
            'Regular.Std.printer ->
            'Graphlib.Std.Path.t Regular.Std.printer
        end
      module Partition :
        sig
          type 'a t = 'Graphlib.Std.partition
          val groups :
            'Graphlib.Std.Partition.t ->
            'Graphlib.Std.group Regular.Std.seq
          val group :
            'Graphlib.Std.Partition.t -> '-> 'Graphlib.Std.group option
          val equiv : 'Graphlib.Std.Partition.t -> '-> '-> bool
          val number_of_groups : 'Graphlib.Std.Partition.t -> int
          val of_equiv :
            'Graphlib.Std.Partition.t ->
            Graphlib.Std.equiv -> 'Graphlib.Std.group option
          val pp :
            'Regular.Std.printer ->
            'Graphlib.Std.Partition.t Regular.Std.printer
        end
      module Group :
        sig
          type 'a t = 'Graphlib.Std.group
          val enum : 'Graphlib.Std.group -> 'Regular.Std.seq
          val mem : 'Graphlib.Std.group -> '-> bool
          val top : 'Graphlib.Std.group -> 'a
          val to_equiv : 'Graphlib.Std.group -> Graphlib.Std.equiv
          val pp :
            'Regular.Std.printer ->
            'Graphlib.Std.Group.t Regular.Std.printer
        end
      module Equiv :
        sig
          type t = Graphlib.Std.equiv
          val to_int : Graphlib.Std.Equiv.t -> int
          val t_of_sexp : Sexplib.Sexp.t -> t
          val sexp_of_t : t -> Sexplib.Sexp.t
          val bin_t : t Core_kernel.Std.Bin_prot.Type_class.t
          val bin_read_t : t Core_kernel.Std.Bin_prot.Read.reader
          val __bin_read_t__ :
            (int -> t) Core_kernel.Std.Bin_prot.Read.reader
          val bin_reader_t : t Core_kernel.Std.Bin_prot.Type_class.reader
          val bin_size_t : t Core_kernel.Std.Bin_prot.Size.sizer
          val bin_write_t : t Core_kernel.Std.Bin_prot.Write.writer
          val bin_writer_t : t Core_kernel.Std.Bin_prot.Type_class.writer
          val bin_shape_t : Core_kernel.Std.Bin_prot.Shape.t
          val to_string : t -> string
          val str : unit -> t -> string
          val pps : unit -> t -> string
          val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
          val pp_seq :
            Format.formatter -> t Core_kernel.Std.Sequence.t -> unit
          val pp : Base__.Import.Caml.Format.formatter -> t -> unit
          val ( >= ) : t -> t -> bool
          val ( <= ) : t -> t -> bool
          val ( = ) : t -> t -> bool
          val ( > ) : t -> t -> bool
          val ( < ) : t -> t -> bool
          val ( <> ) : t -> t -> bool
          val equal : t -> t -> bool
          val compare : t -> t -> int
          val min : t -> t -> t
          val max : t -> t -> t
          val ascending : t -> t -> int
          val descending : t -> t -> int
          val between : t -> low:t -> high:t -> bool
          val clamp_exn : t -> min:t -> max:t -> t
          val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
          type comparator_witness
          val validate_lbound :
            min:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_ubound :
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          val validate_bound :
            min:t Base__.Maybe_bound.t ->
            max:t Base__.Maybe_bound.t -> t Base__.Validate.check
          module Replace_polymorphic_compare :
            sig
              val ( >= ) : t -> t -> bool
              val ( <= ) : t -> t -> bool
              val ( = ) : t -> t -> bool
              val ( > ) : t -> t -> bool
              val ( < ) : t -> t -> bool
              val ( <> ) : t -> t -> bool
              val equal : t -> t -> bool
              val compare : t -> t -> int
              val min : t -> t -> t
              val max : t -> t -> t
            end
          val comparator :
            (t, comparator_witness) Core_kernel__.Comparator.comparator
          module Map :
            sig
              module Key :
                sig
                  type t = Graphlib.Std.equiv
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  type comparator_witness = comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type 'a t =
                      (Key.t, 'a, comparator_witness)
                      Core_kernel__.Core_map_intf.Tree.t
                  val empty : 'a t
                  val singleton : Key.t -> '-> 'a t
                  val of_alist :
                    (Key.t * 'a) list ->
                    [ `Duplicate_key of Key.t | `Ok of 'a t ]
                  val of_alist_or_error :
                    (Key.t * 'a) list -> 'a t Base__.Or_error.t
                  val of_alist_exn : (Key.t * 'a) list -> 'a t
                  val of_alist_multi : (Key.t * 'a) list -> 'a list t
                  val of_alist_fold :
                    (Key.t * 'a) list ->
                    init:'-> f:('-> '-> 'b) -> 'b t
                  val of_alist_reduce :
                    (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                  val of_sorted_array :
                    (Key.t * 'a) array -> 'a t Base__.Or_error.t
                  val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Key.t * 'a) -> 'a t
                  val of_iteri :
                    iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                    [ `Duplicate_key of Key.t | `Ok of 'v t ]
                  val of_tree : 'a t -> 'a t
                  val of_hashtbl_exn :
                    (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                  val gen :
                    Key.t Core_kernel__.Quickcheck.Generator.t ->
                    'Core_kernel__.Quickcheck.Generator.t ->
                    'a t Core_kernel__.Quickcheck.Generator.t
                  val invariants : 'a t -> bool
                  val is_empty : 'a t -> bool
                  val length : 'a t -> int
                  val add : 'a t -> key:Key.t -> data:'-> 'a t
                  val add_multi :
                    'a list t -> key:Key.t -> data:'-> 'a list t
                  val remove_multi : 'a list t -> Key.t -> 'a list t
                  val change :
                    'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                  val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                  val find : 'a t -> Key.t -> 'a option
                  val find_exn : 'a t -> Key.t -> 'a
                  val remove : 'a t -> Key.t -> 'a t
                  val mem : 'a t -> Key.t -> bool
                  val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                  val iter : 'a t -> f:('-> unit) -> unit
                  val iteri :
                    'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                  val iter2 :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       unit) ->
                    unit
                  val map : 'a t -> f:('-> 'b) -> 'b t
                  val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                  val fold :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold_right :
                    'a t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val fold2 :
                    'a t ->
                    'b t ->
                    init:'->
                    f:(key:Key.t ->
                       data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       '-> 'c) ->
                    'c
                  val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                  val filter : 'a t -> f:('-> bool) -> 'a t
                  val filteri :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                  val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                  val filter_mapi :
                    'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                  val partition_mapi :
                    'a t ->
                    f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                    'b t * 'c t
                  val partition_map :
                    'a t ->
                    f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                  val partitioni_tf :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                  val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                  val compare_direct :
                    ('-> '-> int) -> 'a t -> 'a t -> int
                  val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                  val keys : 'a t -> Key.t list
                  val data : 'a t -> 'a list
                  val to_alist :
                    ?key_order:[ `Decreasing | `Increasing ] ->
                    'a t -> (Key.t * 'a) list
                  val validate :
                    name:(Key.t -> string) ->
                    'Base__.Validate.check -> 'a t Base__.Validate.check
                  val merge :
                    'a t ->
                    'b t ->
                    f:(key:Key.t ->
                       [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                       'c option) ->
                    'c t
                  val symmetric_diff :
                    'a t ->
                    'a t ->
                    data_equal:('-> '-> bool) ->
                    (Key.t, 'a)
                    Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                    Base__.Sequence.t
                  val min_elt : 'a t -> (Key.t * 'a) option
                  val min_elt_exn : 'a t -> Key.t * 'a
                  val max_elt : 'a t -> (Key.t * 'a) option
                  val max_elt_exn : 'a t -> Key.t * 'a
                  val for_all : 'a t -> f:('-> bool) -> bool
                  val for_alli :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val exists : 'a t -> f:('-> bool) -> bool
                  val existsi :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                  val count : 'a t -> f:('-> bool) -> int
                  val counti :
                    'a t -> f:(key:Key.t -> data:'-> bool) -> int
                  val split :
                    'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                  val append :
                    lower_part:'a t ->
                    upper_part:'a t ->
                    [ `Ok of 'a t | `Overlapping_key_ranges ]
                  val subrange :
                    'a t ->
                    lower_bound:Key.t Base__.Maybe_bound.t ->
                    upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                  val fold_range_inclusive :
                    'a t ->
                    min:Key.t ->
                    max:Key.t ->
                    init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                  val range_to_alist :
                    'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                  val closest_key :
                    'a t ->
                    [ `Greater_or_equal_to
                    | `Greater_than
                    | `Less_or_equal_to
                    | `Less_than ] -> Key.t -> (Key.t * 'a) option
                  val nth : 'a t -> int -> (Key.t * 'a) option
                  val nth_exn : 'a t -> int -> Key.t * 'a
                  val rank : 'a t -> Key.t -> int option
                  val to_tree : 'a t -> 'a t
                  val to_sequence :
                    ?order:[ `Decreasing_key | `Increasing_key ] ->
                    ?keys_greater_or_equal_to:Key.t ->
                    ?keys_less_or_equal_to:Key.t ->
                    'a t -> (Key.t * 'a) Base__.Sequence.t
                  val obs :
                    Key.t Core_kernel__.Quickcheck.Observer.t ->
                    'Core_kernel__.Quickcheck.Observer.t ->
                    'v t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                    'Core_kernel__.Quickcheck.Shrinker.t ->
                    'v t Core_kernel__.Quickcheck.Shrinker.t
                  module Provide_of_sexp :
                    functor
                      (K : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                      sig
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__017_) ->
                          Sexplib.Sexp.t -> 'v_x__017_ t
                      end
                  val t_of_sexp :
                    (Base__.Sexplib.Sexp.t -> 'a) ->
                    Base__.Sexplib.Sexp.t -> 'a t
                  val sexp_of_t :
                    ('-> Base__.Sexplib.Sexp.t) ->
                    'a t -> Base__.Sexplib.Sexp.t
                end
              type 'a t =
                  (Key.t, 'a, comparator_witness)
                  Core_kernel__.Core_map_intf.Map.t
              val compare :
                ('-> '-> Core_kernel__.Import.int) ->
                'a t -> 'a t -> Core_kernel__.Import.int
              val empty : 'a t
              val singleton : Key.t -> '-> 'a t
              val of_alist :
                (Key.t * 'a) list ->
                [ `Duplicate_key of Key.t | `Ok of 'a t ]
              val of_alist_or_error :
                (Key.t * 'a) list -> 'a t Base__.Or_error.t
              val of_alist_exn : (Key.t * 'a) list -> 'a t
              val of_alist_multi : (Key.t * 'a) list -> 'a list t
              val of_alist_fold :
                (Key.t * 'a) list -> init:'-> f:('-> '-> 'b) -> 'b t
              val of_alist_reduce :
                (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
              val of_sorted_array :
                (Key.t * 'a) array -> 'a t Base__.Or_error.t
              val of_sorted_array_unchecked : (Key.t * 'a) array -> 'a t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Key.t * 'a) -> 'a t
              val of_iteri :
                iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                [ `Duplicate_key of Key.t | `Ok of 'v t ]
              val of_tree : 'Tree.t -> 'a t
              val of_hashtbl_exn :
                (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
              val gen :
                Key.t Core_kernel__.Quickcheck.Generator.t ->
                'Core_kernel__.Quickcheck.Generator.t ->
                'a t Core_kernel__.Quickcheck.Generator.t
              val invariants : 'a t -> bool
              val is_empty : 'a t -> bool
              val length : 'a t -> int
              val add : 'a t -> key:Key.t -> data:'-> 'a t
              val add_multi : 'a list t -> key:Key.t -> data:'-> 'a list t
              val remove_multi : 'a list t -> Key.t -> 'a list t
              val change :
                'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
              val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
              val find : 'a t -> Key.t -> 'a option
              val find_exn : 'a t -> Key.t -> 'a
              val remove : 'a t -> Key.t -> 'a t
              val mem : 'a t -> Key.t -> bool
              val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
              val iter : 'a t -> f:('-> unit) -> unit
              val iteri : 'a t -> f:(key:Key.t -> data:'-> unit) -> unit
              val iter2 :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   unit) ->
                unit
              val map : 'a t -> f:('-> 'b) -> 'b t
              val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
              val fold :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold_right :
                'a t -> init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val fold2 :
                'a t ->
                'b t ->
                init:'->
                f:(key:Key.t ->
                   data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   '-> 'c) ->
                'c
              val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
              val filter : 'a t -> f:('-> bool) -> 'a t
              val filteri : 'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
              val filter_map : 'a t -> f:('-> 'b option) -> 'b t
              val filter_mapi :
                'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
              val partition_mapi :
                'a t ->
                f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                'b t * 'c t
              val partition_map :
                'a t -> f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
              val partitioni_tf :
                'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
              val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
              val compare_direct : ('-> '-> int) -> 'a t -> 'a t -> int
              val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
              val keys : 'a t -> Key.t list
              val data : 'a t -> 'a list
              val to_alist :
                ?key_order:[ `Decreasing | `Increasing ] ->
                'a t -> (Key.t * 'a) list
              val validate :
                name:(Key.t -> string) ->
                'Base__.Validate.check -> 'a t Base__.Validate.check
              val merge :
                'a t ->
                'b t ->
                f:(key:Key.t ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              val symmetric_diff :
                'a t ->
                'a t ->
                data_equal:('-> '-> bool) ->
                (Key.t, 'a)
                Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                Base__.Sequence.t
              val min_elt : 'a t -> (Key.t * 'a) option
              val min_elt_exn : 'a t -> Key.t * 'a
              val max_elt : 'a t -> (Key.t * 'a) option
              val max_elt_exn : 'a t -> Key.t * 'a
              val for_all : 'a t -> f:('-> bool) -> bool
              val for_alli : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val exists : 'a t -> f:('-> bool) -> bool
              val existsi : 'a t -> f:(key:Key.t -> data:'-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val counti : 'a t -> f:(key:Key.t -> data:'-> bool) -> int
              val split : 'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
              val append :
                lower_part:'a t ->
                upper_part:'a t -> [ `Ok of 'a t | `Overlapping_key_ranges ]
              val subrange :
                'a t ->
                lower_bound:Key.t Base__.Maybe_bound.t ->
                upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
              val fold_range_inclusive :
                'a t ->
                min:Key.t ->
                max:Key.t ->
                init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
              val range_to_alist :
                'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
              val closest_key :
                'a t ->
                [ `Greater_or_equal_to
                | `Greater_than
                | `Less_or_equal_to
                | `Less_than ] -> Key.t -> (Key.t * 'a) option
              val nth : 'a t -> int -> (Key.t * 'a) option
              val nth_exn : 'a t -> int -> Key.t * 'a
              val rank : 'a t -> Key.t -> int option
              val to_tree : 'a t -> 'Tree.t
              val to_sequence :
                ?order:[ `Decreasing_key | `Increasing_key ] ->
                ?keys_greater_or_equal_to:Key.t ->
                ?keys_less_or_equal_to:Key.t ->
                'a t -> (Key.t * 'a) Base__.Sequence.t
              val obs :
                Key.t Core_kernel__.Quickcheck.Observer.t ->
                'Core_kernel__.Quickcheck.Observer.t ->
                'v t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                'Core_kernel__.Quickcheck.Shrinker.t ->
                'v t Core_kernel__.Quickcheck.Shrinker.t
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> Key.t end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__018_) ->
                      Sexplib.Sexp.t -> 'v_x__018_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : Key.t Bin_prot.Type_class.t
                           val bin_read_t : Key.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Key.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Key.t Bin_prot.Type_class.reader
                           val bin_size_t : Key.t Bin_prot.Size.sizer
                           val bin_write_t : Key.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Key.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                    val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                    val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                    val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                    val __bin_read_t__ :
                      ('a, int -> 'a t) Bin_prot.Read.reader1
                    val bin_writer_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.writer
                    val bin_reader_t :
                      ('a, 'a t) Bin_prot.Type_class.S1.reader
                    val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                  end
              module Provide_hash :
                functor
                  (Key : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Key.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      (Ppx_hash_lib.Std.Hash.state ->
                       '-> Ppx_hash_lib.Std.Hash.state) ->
                      Ppx_hash_lib.Std.Hash.state ->
                      'a t -> Ppx_hash_lib.Std.Hash.state
                  end
              val t_of_sexp :
                (Base__.Sexplib.Sexp.t -> 'a) ->
                Base__.Sexplib.Sexp.t -> 'a t
              val sexp_of_t :
                ('-> Base__.Sexplib.Sexp.t) ->
                'a t -> Base__.Sexplib.Sexp.t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Set :
            sig
              module Elt :
                sig
                  type t = Map.Key.t
                  val bin_t : t Bin_prot.Type_class.t
                  val bin_read_t : t Bin_prot.Read.reader
                  val __bin_read_t__ :
                    (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                  val bin_reader_t : t Bin_prot.Type_class.reader
                  val bin_size_t : t Bin_prot.Size.sizer
                  val bin_write_t : t Bin_prot.Write.writer
                  val bin_writer_t : t Bin_prot.Type_class.writer
                  val bin_shape_t : Bin_prot.Shape.t
                  val t_of_sexp : Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Sexplib.Sexp.t
                  type comparator_witness = Map.Key.comparator_witness
                  val comparator :
                    (t, comparator_witness)
                    Core_kernel__.Comparator.comparator
                end
              module Tree :
                sig
                  type t =
                      (Elt.t, comparator_witness)
                      Core_kernel__.Core_set_intf.Tree.t
                  val compare : t -> t -> Core_kernel__.Import.int
                  val length : t -> int
                  val is_empty : t -> bool
                  val iter : t -> f:(Elt.t -> unit) -> unit
                  val fold :
                    t ->
                    init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                  val fold_result :
                    t ->
                    init:'accum ->
                    f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                    ('accum, 'e) Base__.Result.t
                  val exists : t -> f:(Elt.t -> bool) -> bool
                  val for_all : t -> f:(Elt.t -> bool) -> bool
                  val count : t -> f:(Elt.t -> bool) -> int
                  val sum :
                    (module Base__.Commutative_group.S with type t = 'sum) ->
                    t -> f:(Elt.t -> 'sum) -> 'sum
                  val find : t -> f:(Elt.t -> bool) -> Elt.t option
                  val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                  val to_list : t -> Elt.t list
                  val to_array : t -> Elt.t array
                  val invariants : t -> bool
                  val mem : t -> Elt.t -> bool
                  val add : t -> Elt.t -> t
                  val remove : t -> Elt.t -> t
                  val union : t -> t -> t
                  val inter : t -> t -> t
                  val diff : t -> t -> t
                  val symmetric_diff :
                    t ->
                    t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                  val compare_direct : t -> t -> int
                  val equal : t -> t -> bool
                  val is_subset : t -> of_:t -> bool
                  val subset : t -> t -> bool
                  val fold_until :
                    t ->
                    init:'->
                    f:('->
                       Elt.t ->
                       ('b, 'stop)
                       Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                    ('b, 'stop)
                    Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                  val fold_right :
                    t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                  val iter2 :
                    t ->
                    t ->
                    f:([ `Both of Elt.t * Elt.t
                       | `Left of Elt.t
                       | `Right of Elt.t ] -> unit) ->
                    unit
                  val filter : t -> f:(Elt.t -> bool) -> t
                  val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                  val elements : t -> Elt.t list
                  val min_elt : t -> Elt.t option
                  val min_elt_exn : t -> Elt.t
                  val max_elt : t -> Elt.t option
                  val max_elt_exn : t -> Elt.t
                  val choose : t -> Elt.t option
                  val choose_exn : t -> Elt.t
                  val split : t -> Elt.t -> t * Elt.t option * t
                  val group_by :
                    t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                  val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                  val find_index : t -> int -> Elt.t option
                  val nth : t -> int -> Elt.t option
                  val remove_index : t -> int -> t
                  val to_tree : t -> t
                  val to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                  val merge_to_sequence :
                    ?order:[ `Decreasing | `Increasing ] ->
                    ?greater_or_equal_to:Elt.t ->
                    ?less_or_equal_to:Elt.t ->
                    t ->
                    t ->
                    (Elt.t, Elt.t)
                    Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                    Base__.Sequence.t
                  val to_map :
                    t ->
                    f:(Elt.t -> 'data) ->
                    (Elt.t, 'data, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t
                  val obs :
                    Elt.t Core_kernel__.Quickcheck.Observer.t ->
                    t Core_kernel__.Quickcheck.Observer.t
                  val shrinker :
                    Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                    t Core_kernel__.Quickcheck.Shrinker.t
                  val empty : t
                  val singleton : Elt.t -> t
                  val union_list : t list -> t
                  val of_list : Elt.t list -> t
                  val of_array : Elt.t array -> t
                  val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                  val of_sorted_array_unchecked : Elt.t array -> t
                  val of_increasing_iterator_unchecked :
                    len:int -> f:(int -> Elt.t) -> t
                  val stable_dedup_list : Elt.t list -> Elt.t list
                  val map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t) -> t
                  val filter_map :
                    ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                    f:('-> Elt.t option) -> t
                  val of_tree : t -> t
                  val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                  val of_hashtbl_keys :
                    (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                  val of_map_keys :
                    (Elt.t, 'a, comparator_witness)
                    Core_kernel__.Core_set_intf.Map.t -> t
                  val gen :
                    Elt.t Core_kernel__.Quickcheck.Generator.t ->
                    t Core_kernel__.Quickcheck.Generator.t
                  module Provide_of_sexp :
                    functor
                      (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                      sig val t_of_sexp : Sexplib.Sexp.t -> t end
                  val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                end
              type t = (Elt.t, comparator_witness) Base.Set.t
              val compare : t -> t -> Core_kernel__.Import.int
              val length : t -> int
              val is_empty : t -> bool
              val iter : t -> f:(Elt.t -> unit) -> unit
              val fold :
                t -> init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
              val fold_result :
                t ->
                init:'accum ->
                f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val exists : t -> f:(Elt.t -> bool) -> bool
              val for_all : t -> f:(Elt.t -> bool) -> bool
              val count : t -> f:(Elt.t -> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                t -> f:(Elt.t -> 'sum) -> 'sum
              val find : t -> f:(Elt.t -> bool) -> Elt.t option
              val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
              val to_list : t -> Elt.t list
              val to_array : t -> Elt.t array
              val invariants : t -> bool
              val mem : t -> Elt.t -> bool
              val add : t -> Elt.t -> t
              val remove : t -> Elt.t -> t
              val union : t -> t -> t
              val inter : t -> t -> t
              val diff : t -> t -> t
              val symmetric_diff :
                t -> t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
              val compare_direct : t -> t -> int
              val equal : t -> t -> bool
              val is_subset : t -> of_:t -> bool
              val subset : t -> t -> bool
              val fold_until :
                t ->
                init:'->
                f:('->
                   Elt.t ->
                   ('b, 'stop)
                   Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                ('b, 'stop)
                Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
              val fold_right : t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
              val iter2 :
                t ->
                t ->
                f:([ `Both of Elt.t * Elt.t
                   | `Left of Elt.t
                   | `Right of Elt.t ] -> unit) ->
                unit
              val filter : t -> f:(Elt.t -> bool) -> t
              val partition_tf : t -> f:(Elt.t -> bool) -> t * t
              val elements : t -> Elt.t list
              val min_elt : t -> Elt.t option
              val min_elt_exn : t -> Elt.t
              val max_elt : t -> Elt.t option
              val max_elt_exn : t -> Elt.t
              val choose : t -> Elt.t option
              val choose_exn : t -> Elt.t
              val split : t -> Elt.t -> t * Elt.t option * t
              val group_by : t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
              val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
              val find_index : t -> int -> Elt.t option
              val nth : t -> int -> Elt.t option
              val remove_index : t -> int -> t
              val to_tree : t -> Tree.t
              val to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
              val merge_to_sequence :
                ?order:[ `Decreasing | `Increasing ] ->
                ?greater_or_equal_to:Elt.t ->
                ?less_or_equal_to:Elt.t ->
                t ->
                t ->
                (Elt.t, Elt.t)
                Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                Base__.Sequence.t
              val to_map :
                t ->
                f:(Elt.t -> 'data) ->
                (Elt.t, 'data, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t
              val obs :
                Elt.t Core_kernel__.Quickcheck.Observer.t ->
                t Core_kernel__.Quickcheck.Observer.t
              val shrinker :
                Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                t Core_kernel__.Quickcheck.Shrinker.t
              val empty : t
              val singleton : Elt.t -> t
              val union_list : t list -> t
              val of_list : Elt.t list -> t
              val of_array : Elt.t array -> t
              val of_sorted_array : Elt.t array -> t Base__.Or_error.t
              val of_sorted_array_unchecked : Elt.t array -> t
              val of_increasing_iterator_unchecked :
                len:int -> f:(int -> Elt.t) -> t
              val stable_dedup_list : Elt.t list -> Elt.t list
              val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
              val filter_map :
                ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
              val of_tree : Tree.t -> t
              val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
              val of_hashtbl_keys :
                (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
              val of_map_keys :
                (Elt.t, 'a, comparator_witness)
                Core_kernel__.Core_set_intf.Map.t -> t
              val gen :
                Elt.t Core_kernel__.Quickcheck.Generator.t ->
                t Core_kernel__.Quickcheck.Generator.t
              module Provide_of_sexp :
                functor
                  (Elt : sig val t_of_sexp : Sexplib.Sexp.t -> Elt.t end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (Elt : sig
                           val bin_t : Elt.t Bin_prot.Type_class.t
                           val bin_read_t : Elt.t Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> Elt.t)
                             Bin_prot.Read.reader
                           val bin_reader_t :
                             Elt.t Bin_prot.Type_class.reader
                           val bin_size_t : Elt.t Bin_prot.Size.sizer
                           val bin_write_t : Elt.t Bin_prot.Write.writer
                           val bin_writer_t :
                             Elt.t Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
                    val bin_shape_t : Bin_prot.Shape.t
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_t : t Bin_prot.Type_class.t
                  end
              module Provide_hash :
                functor
                  (Elt : sig
                           val hash_fold_t :
                             Base__.Hash.state -> Elt.t -> Base__.Hash.state
                         end->
                  sig
                    val hash_fold_t :
                      Ppx_hash_lib.Std.Hash.state ->
                      t -> Ppx_hash_lib.Std.Hash.state
                    val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                  end
              val t_of_sexp : Base__.Sexplib.Sexp.t -> t
              val sexp_of_t : t -> Base__.Sexplib.Sexp.t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          val hash : t -> Core_kernel__.Import.int
          val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
          module Table :
            sig
              type key = t
              type ('a, 'b) hashtbl =
                  ('a, 'b) Core_kernel.Std.Hashable.Hashtbl.t
              type 'b t = (key, 'b) hashtbl
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
              type ('a, 'b) t_ = 'b t
              type 'a key_ = key
              val hashable : key Core_kernel__.Core_hashtbl_intf.Hashable.t
              val invariant :
                'Base__.Invariant_intf.inv ->
                'a t Base__.Invariant_intf.inv
              val create :
                (key, 'b, unit -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist :
                (key, 'b,
                 (key * 'b) list -> [ `Duplicate_key of key | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_report_all_dups :
                (key, 'b,
                 (key * 'b) list ->
                 [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_or_error :
                (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_exn :
                (key, 'b, (key * 'b) list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val of_alist_multi :
                (key, 'b list, (key * 'b) list -> 'b list t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_mapped :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'b t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key :
                (key, 'r,
                 get_key:('-> key) ->
                 'r list -> [ `Duplicate_keys of key list | `Ok of 'r t ])
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_or_error :
                (key, 'r,
                 get_key:('-> key) -> 'r list -> 'r t Base__.Or_error.t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val create_with_key_exn :
                (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val group :
                (key, 'b,
                 get_key:('-> key) ->
                 get_data:('-> 'b) ->
                 combine:('-> '-> 'b) -> 'r list -> 'b t)
                Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
              val sexp_of_key : 'a t -> key -> Base__.Sexp.t
              val clear : 'a t -> unit
              val copy : 'b t -> 'b t
              val fold :
                'b t -> init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
              val iter_keys : 'a t -> f:(key -> unit) -> unit
              val iter : 'b t -> f:('-> unit) -> unit
              val iteri : 'b t -> f:(key:key -> data:'-> unit) -> unit
              val iter_vals : 'b t -> f:('-> unit) -> unit
              val existsi : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val exists : 'b t -> f:('-> bool) -> bool
              val for_alli : 'b t -> f:(key:key -> data:'-> bool) -> bool
              val for_all : 'b t -> f:('-> bool) -> bool
              val counti : 'b t -> f:(key:key -> data:'-> bool) -> int
              val count : 'b t -> f:('-> bool) -> int
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val mem : 'a t -> key -> bool
              val remove : 'a t -> key -> unit
              val replace : 'b t -> key:key -> data:'-> unit
              val set : 'b t -> key:key -> data:'-> unit
              val add : 'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
              val add_or_error :
                'b t -> key:key -> data:'-> unit Base__.Or_error.t
              val add_exn : 'b t -> key:key -> data:'-> unit
              val change : 'b t -> key -> f:('b option -> 'b option) -> unit
              val update : 'b t -> key -> f:('b option -> 'b) -> unit
              val add_multi : 'b list t -> key:key -> data:'-> unit
              val remove_multi : 'a list t -> key -> unit
              val map : 'b t -> f:('-> 'c) -> 'c t
              val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
              val filter_map : 'b t -> f:('-> 'c option) -> 'c t
              val filter_mapi :
                'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
              val filter_keys : 'b t -> f:(key -> bool) -> 'b t
              val filter : 'b t -> f:('-> bool) -> 'b t
              val filteri : 'b t -> f:(key:key -> data:'-> bool) -> 'b t
              val partition_map :
                'b t -> f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
              val partition_mapi :
                'b t ->
                f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                'c t * 'd t
              val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
              val partitioni_tf :
                'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
              val find_or_add : 'b t -> key -> default:(unit -> 'b) -> 'b
              val find : 'b t -> key -> 'b option
              val find_exn : 'b t -> key -> 'b
              val find_and_call :
                'b t ->
                key -> if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
              val find_and_remove : 'b t -> key -> 'b option
              val merge :
                'a t ->
                'b t ->
                f:(key:key ->
                   [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                   'c option) ->
                'c t
              type 'a merge_into_action = Remove | Set_to of 'a
              val merge_into :
                src:'a t ->
                dst:'b t ->
                f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                unit
              val keys : 'a t -> key list
              val data : 'b t -> 'b list
              val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
              val filter_inplace : 'b t -> f:('-> bool) -> unit
              val filteri_inplace :
                'b t -> f:(key:key -> data:'-> bool) -> unit
              val map_inplace : 'b t -> f:('-> 'b) -> unit
              val mapi_inplace : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_map_inplace : 'b t -> f:('-> 'b option) -> unit
              val filter_mapi_inplace :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val replace_all : 'b t -> f:('-> 'b) -> unit
              val replace_alli : 'b t -> f:(key:key -> data:'-> 'b) -> unit
              val filter_replace_all : 'b t -> f:('-> 'b option) -> unit
              val filter_replace_alli :
                'b t -> f:(key:key -> data:'-> 'b option) -> unit
              val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
              val similar : 'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
              val to_alist : 'b t -> (key * 'b) list
              val validate :
                name:(key -> string) ->
                'Base__.Validate.check -> 'b t Base__.Validate.check
              val incr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              val decr :
                ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
              module Provide_of_sexp :
                functor
                  (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                  sig
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__001_) ->
                      Sexplib.Sexp.t -> 'v_x__001_ t
                  end
              module Provide_bin_io :
                functor
                  (Key : sig
                           val bin_t : key Bin_prot.Type_class.t
                           val bin_read_t : key Bin_prot.Read.reader
                           val __bin_read_t__ :
                             (Core_kernel__.Import.int -> key)
                             Bin_prot.Read.reader
                           val bin_reader_t : key Bin_prot.Type_class.reader
                           val bin_size_t : key Bin_prot.Size.sizer
                           val bin_write_t : key Bin_prot.Write.writer
                           val bin_writer_t : key Bin_prot.Type_class.writer
                           val bin_shape_t : Bin_prot.Shape.t
                         end->
                  sig
                    val bin_t :
                      'Bin_prot.Type_class.t -> 'a t Bin_prot.Type_class.t
                    val bin_read_t :
                      'Bin_prot.Read.reader -> 'a t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      'Bin_prot.Read.reader ->
                      (Core_kernel__.Import.int -> 'a t) Bin_prot.Read.reader
                    val bin_reader_t :
                      'Bin_prot.Type_class.reader ->
                      'a t Bin_prot.Type_class.reader
                    val bin_size_t :
                      'Bin_prot.Size.sizer -> 'a t Bin_prot.Size.sizer
                    val bin_write_t :
                      'Bin_prot.Write.writer -> 'a t Bin_prot.Write.writer
                    val bin_writer_t :
                      'Bin_prot.Type_class.writer ->
                      'a t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
                  end
              val t_of_sexp :
                (Sexplib.Sexp.t -> 'v_x__002_) ->
                Sexplib.Sexp.t -> 'v_x__002_ t
              val bin_shape_t : Bin_prot.Shape.t -> Bin_prot.Shape.t
              val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
              val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
              val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
              val __bin_read_t__ : ('a, int -> 'a t) Bin_prot.Read.reader1
              val bin_writer_t : ('a, 'a t) Bin_prot.Type_class.S1.writer
              val bin_reader_t : ('a, 'a t) Bin_prot.Type_class.S1.reader
              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
            end
          module Hash_set :
            sig
              type elt = t
              type t = elt Core_kernel__.Hash_set.t
              val sexp_of_t : t -> Sexplib.Sexp.t
              type 'a t_ = t
              type 'a elt_ = elt
              val create :
                ('a, unit -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              val of_list :
                ('a, elt list -> t)
                Core_kernel__.Hash_set_intf.create_options_without_hashable
              module Provide_of_sexp :
                functor
                  (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                  sig val t_of_sexp : Sexplib.Sexp.t -> t end
              module Provide_bin_io :
                functor
                  (X : sig
                         val bin_t : elt Bin_prot.Type_class.t
                         val bin_read_t : elt Bin_prot.Read.reader
                         val __bin_read_t__ :
                           (Core_kernel__.Import.int -> elt)
                           Bin_prot.Read.reader
                         val bin_reader_t : elt Bin_prot.Type_class.reader
                         val bin_size_t : elt Bin_prot.Size.sizer
                         val bin_write_t : elt Bin_prot.Write.writer
                         val bin_writer_t : elt Bin_prot.Type_class.writer
                         val bin_shape_t : Bin_prot.Shape.t
                       end->
                  sig
                    val bin_t : t Bin_prot.Type_class.t
                    val bin_read_t : t Bin_prot.Read.reader
                    val __bin_read_t__ :
                      (Core_kernel__.Import.int -> t) Bin_prot.Read.reader
                    val bin_reader_t : t Bin_prot.Type_class.reader
                    val bin_size_t : t Bin_prot.Size.sizer
                    val bin_write_t : t Bin_prot.Write.writer
                    val bin_writer_t : t Bin_prot.Type_class.writer
                    val bin_shape_t : Bin_prot.Shape.t
                  end
              val t_of_sexp : Sexplib.Sexp.t -> t
              val bin_size_t : t Bin_prot.Size.sizer
              val bin_write_t : t Bin_prot.Write.writer
              val bin_read_t : t Bin_prot.Read.reader
              val __bin_read_t__ : (int -> t) Bin_prot.Read.reader
              val bin_shape_t : Bin_prot.Shape.t
              val bin_writer_t : t Bin_prot.Type_class.writer
              val bin_reader_t : t Bin_prot.Type_class.reader
              val bin_t : t Bin_prot.Type_class.t
            end
          module Hash_queue :
            sig
              module Key :
                sig
                  type t = Hash_set.elt
                  val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  val compare : t -> t -> int
                  val hash : t -> int
                end
              type 'a t
              val sexp_of_t :
                ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
              val length : 'a t -> int
              val is_empty : 'a t -> bool
              val iter : 'a t -> f:('-> unit) -> unit
              val fold :
                'a t -> init:'accum -> f:('accum -> '-> 'accum) -> 'accum
              val fold_result :
                'a t ->
                init:'accum ->
                f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                ('accum, 'e) Base__.Result.t
              val fold_until :
                'a t ->
                init:'accum ->
                f:('accum ->
                   '->
                   ('accum, 'stop) Base.Container_intf.Continue_or_stop.t) ->
                ('accum, 'stop)
                Base.Container_intf.Finished_or_stopped_early.t
              val exists : 'a t -> f:('-> bool) -> bool
              val for_all : 'a t -> f:('-> bool) -> bool
              val count : 'a t -> f:('-> bool) -> int
              val sum :
                (module Base__.Commutative_group.S with type t = 'sum) ->
                'a t -> f:('-> 'sum) -> 'sum
              val find : 'a t -> f:('-> bool) -> 'a option
              val find_map : 'a t -> f:('-> 'b option) -> 'b option
              val to_list : 'a t -> 'a list
              val to_array : 'a t -> 'a array
              val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
              val invariant : 'a t -> Core_kernel__.Import.unit
              val create :
                ?growth_allowed:Core_kernel__.Import.bool ->
                ?size:Core_kernel__.Import.int ->
                Core_kernel__.Import.unit -> 'a t
              val clear : 'a t -> Core_kernel__.Import.unit
              val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
              val lookup : 'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_exn : 'a t -> Key.t -> 'a
              val enqueue :
                'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
              val enqueue_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val lookup_and_move_to_back :
                'a t -> Key.t -> 'Core_kernel__.Import.option
              val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
              val first : 'a t -> 'Core_kernel__.Import.option
              val first_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val keys : 'a t -> Key.t Core_kernel__.Import.list
              val dequeue : 'a t -> 'Core_kernel__.Import.option
              val dequeue_exn : 'a t -> 'a
              val dequeue_with_key :
                'a t -> (Key.t * 'a) Core_kernel__.Import.option
              val dequeue_with_key_exn : 'a t -> Key.t * 'a
              val dequeue_all :
                'a t ->
                f:('-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
              val remove_exn : 'a t -> Key.t -> Core_kernel__.Import.unit
              val replace : 'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
              val replace_exn :
                'a t -> Key.t -> '-> Core_kernel__.Import.unit
              val iteri :
                'a t ->
                f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                Core_kernel__.Import.unit
              val foldi :
                'a t -> init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
            end
          type info = string * [ `Ver of string ] * string option
          val version : string
          val size_in_bytes : ?ver:string -> ?fmt:string -> t -> int
          val of_bytes : ?ver:string -> ?fmt:string -> Regular.Std.bytes -> t
          val to_bytes : ?ver:string -> ?fmt:string -> t -> Regular.Std.bytes
          val blit_to_bytes :
            ?ver:string ->
            ?fmt:string -> Regular.Std.bytes -> t -> int -> unit
          val of_bigstring :
            ?ver:string -> ?fmt:string -> Core_kernel.Std.bigstring -> t
          val to_bigstring :
            ?ver:string -> ?fmt:string -> t -> Core_kernel.Std.bigstring
          val blit_to_bigstring :
            ?ver:string ->
            ?fmt:string -> Core_kernel.Std.bigstring -> t -> int -> unit
          module Io :
            sig
              val read : ?ver:string -> ?fmt:string -> string -> t
              val load :
                ?ver:string ->
                ?fmt:string -> Core_kernel.Std.In_channel.t -> t
              val load_all :
                ?ver:string ->
                ?fmt:string ->
                ?rev:bool -> Core_kernel.Std.In_channel.t -> t list
              val scan :
                ?ver:string ->
                ?fmt:string ->
                Core_kernel.Std.In_channel.t -> unit -> t option
              val write : ?ver:string -> ?fmt:string -> string -> t -> unit
              val save :
                ?ver:string ->
                ?fmt:string -> Core_kernel.Std.Out_channel.t -> t -> unit
              val save_all :
                ?ver:string ->
                ?fmt:string ->
                Core_kernel.Std.Out_channel.t -> t list -> unit
              val dump :
                ?ver:string ->
                ?fmt:string ->
                Core_kernel.Std.Out_channel.t -> (unit -> t option) -> unit
              val show : ?ver:string -> ?fmt:string -> t -> unit
              val print :
                ?ver:string -> ?fmt:string -> Format.formatter -> t -> unit
            end
          module Cache :
            sig
              val load : Regular.Std.digest -> t option
              val save : Regular.Std.digest -> t -> unit
            end
          val add_reader :
            ?desc:string ->
            ver:string -> string -> t Regular.Std.reader -> unit
          val add_writer :
            ?desc:string ->
            ver:string -> string -> t Regular.Std.writer -> unit
          val available_readers : unit -> info list
          val default_reader : unit -> info
          val set_default_reader : ?ver:string -> string -> unit
          val with_reader : ?ver:string -> string -> (unit -> 'a) -> 'a
          val available_writers : unit -> info list
          val default_writer : unit -> info
          val set_default_writer : ?ver:string -> string -> unit
          val with_writer : ?ver:string -> string -> (unit -> 'a) -> 'a
          val default_printer : unit -> info option
          val set_default_printer : ?ver:string -> string -> unit
          val with_printer : ?ver:string -> string -> (unit -> 'a) -> 'a
          val find_reader :
            ?ver:string -> string -> t Regular.Std.reader option
          val find_writer :
            ?ver:string -> string -> t Regular.Std.writer option
        end
      module type Predicate =
        sig
          type edge
          type node
          val edge : Graphlib.Std.Predicate.edge -> bool
          val node : Graphlib.Std.Predicate.node -> bool
        end
      module type Isomorphism =
        sig
          type s
          type t
          val forward :
            Graphlib.Std.Isomorphism.s -> Graphlib.Std.Isomorphism.t
          val backward :
            Graphlib.Std.Isomorphism.t -> Graphlib.Std.Isomorphism.s
        end
      class type ['n, 'e, 's] dfs_visitor =
        object
          method enter_edge : Graphlib.Std.edge_kind -> '-> '-> 's
          method enter_node : int -> '-> '-> 's
          method leave_edge : Graphlib.Std.edge_kind -> '-> '-> 's
          method leave_node : int -> '-> '-> 's
          method start_tree : '-> '-> 's
        end
      type node_attr = Graph.Graphviz.DotAttributes.vertex
      type edge_attr = Graph.Graphviz.DotAttributes.edge
      type graph_attr = Graph.Graphviz.DotAttributes.graph
      type ('n, 'a) labeled = { node : 'n; node_label : 'a; }
      module Solution :
        sig
          type ('n, 'd) t
          val create :
            ('n, 'd, 'a) Core_kernel.Std.Map.t ->
            '-> ('n, 'd) Graphlib.Std.Solution.t
          val iterations : ('n, 'd) Graphlib.Std.Solution.t -> int
          val default : ('n, 'd) Graphlib.Std.Solution.t -> 'd
          val is_fixpoint : ('n, 'd) Graphlib.Std.Solution.t -> bool
          val get : ('n, 'd) Graphlib.Std.Solution.t -> '-> 'd
          val derive :
            ('n, 'd) Graphlib.Std.Solution.t ->
            f:('-> '-> 'a option) ->
            '-> ('n, 'a) Graphlib.Std.Solution.t
        end
      module Graphlib :
        sig
          module Make :
            functor
              (Node : Regular.Std.Opaque.S) (Edge : Core_kernel.Std.T->
              sig
                type t
                type node = Node.t
                type edge
                module Node :
                  sig
                    type t = node
                    type graph = t
                    type label = t
                    type edge = edge
                    val create : label -> label
                    val label : label -> label
                    val mem : label -> graph -> bool
                    val succs : label -> graph -> label Regular.Std.seq
                    val preds : label -> graph -> label Regular.Std.seq
                    val inputs : label -> graph -> edge Regular.Std.seq
                    val outputs : label -> graph -> edge Regular.Std.seq
                    val degree : ?dir:[ `In | `Out ] -> label -> graph -> int
                    val insert : label -> graph -> graph
                    val update : label -> label -> graph -> graph
                    val remove : label -> graph -> graph
                    val has_edge : label -> label -> graph -> bool
                    val edge : label -> label -> graph -> edge option
                    val ( >= ) : label -> label -> bool
                    val ( <= ) : label -> label -> bool
                    val ( = ) : label -> label -> bool
                    val ( > ) : label -> label -> bool
                    val ( < ) : label -> label -> bool
                    val ( <> ) : label -> label -> bool
                    val equal : label -> label -> bool
                    val min : label -> label -> label
                    val max : label -> label -> label
                    val ascending : label -> label -> int
                    val descending : label -> label -> int
                    val between : label -> low:label -> high:label -> bool
                    val clamp_exn : label -> min:label -> max:label -> label
                    val clamp :
                      label ->
                      min:label -> max:label -> label Base__.Or_error.t
                    type comparator_witness
                    val comparator :
                      (label, comparator_witness)
                      Base__.Comparator.comparator
                    val validate_lbound :
                      min:label Base__.Maybe_bound.t ->
                      label Base__.Validate.check
                    val validate_ubound :
                      max:label Base__.Maybe_bound.t ->
                      label Base__.Validate.check
                    val validate_bound :
                      min:label Base__.Maybe_bound.t ->
                      max:label Base__.Maybe_bound.t ->
                      label Base__.Validate.check
                    module Replace_polymorphic_compare :
                      sig
                        val ( >= ) : label -> label -> bool
                        val ( <= ) : label -> label -> bool
                        val ( = ) : label -> label -> bool
                        val ( > ) : label -> label -> bool
                        val ( < ) : label -> label -> bool
                        val ( <> ) : label -> label -> bool
                        val equal : label -> label -> bool
                        val compare : label -> label -> int
                        val min : label -> label -> label
                        val max : label -> label -> label
                      end
                    module Map :
                      sig
                        module Key :
                          sig
                            type t = label
                            val t_of_sexp : Sexplib.Sexp.t -> t
                            val sexp_of_t : t -> Sexplib.Sexp.t
                            type comparator_witness = comparator_witness
                            val comparator :
                              (t, comparator_witness)
                              Core_kernel__.Comparator.comparator
                          end
                        module Tree :
                          sig
                            type 'a t =
                                (label, 'a, comparator_witness)
                                Core_kernel__.Core_map_intf.Tree.t
                            val empty : 'a t
                            val singleton : label -> '-> 'a t
                            val of_alist :
                              (label * 'a) list ->
                              [ `Duplicate_key of label | `Ok of 'a t ]
                            val of_alist_or_error :
                              (label * 'a) list -> 'a t Base__.Or_error.t
                            val of_alist_exn : (label * 'a) list -> 'a t
                            val of_alist_multi :
                              (label * 'a) list -> 'a list t
                            val of_alist_fold :
                              (label * 'a) list ->
                              init:'-> f:('-> '-> 'b) -> 'b t
                            val of_alist_reduce :
                              (label * 'a) list -> f:('-> '-> 'a) -> 'a t
                            val of_sorted_array :
                              (label * 'a) array -> 'a t Base__.Or_error.t
                            val of_sorted_array_unchecked :
                              (label * 'a) array -> 'a t
                            val of_increasing_iterator_unchecked :
                              len:int -> f:(int -> label * 'a) -> 'a t
                            val of_iteri :
                              iteri:(f:(key:label -> data:'-> unit) -> unit) ->
                              [ `Duplicate_key of label | `Ok of 'v t ]
                            val of_tree : 'a t -> 'a t
                            val of_hashtbl_exn :
                              (label, 'a) Core_kernel__.Core_hashtbl.t ->
                              'a t
                            val gen :
                              label Core_kernel__.Quickcheck.Generator.t ->
                              'Core_kernel__.Quickcheck.Generator.t ->
                              'a t Core_kernel__.Quickcheck.Generator.t
                            val invariants : 'a t -> bool
                            val is_empty : 'a t -> bool
                            val length : 'a t -> int
                            val add : 'a t -> key:label -> data:'-> 'a t
                            val add_multi :
                              'a list t -> key:label -> data:'-> 'a list t
                            val remove_multi :
                              'a list t -> label -> 'a list t
                            val change :
                              'a t ->
                              label -> f:('a option -> 'a option) -> 'a t
                            val update :
                              'a t -> label -> f:('a option -> 'a) -> 'a t
                            val find : 'a t -> label -> 'a option
                            val find_exn : 'a t -> label -> 'a
                            val remove : 'a t -> label -> 'a t
                            val mem : 'a t -> label -> bool
                            val iter_keys : 'a t -> f:(label -> unit) -> unit
                            val iter : 'a t -> f:('-> unit) -> unit
                            val iteri :
                              'a t ->
                              f:(key:label -> data:'-> unit) -> unit
                            val iter2 :
                              'a t ->
                              'b t ->
                              f:(key:label ->
                                 data:[ `Both of 'a * 'b
                                      | `Left of 'a
                                      | `Right of 'b ] ->
                                 unit) ->
                              unit
                            val map : 'a t -> f:('-> 'b) -> 'b t
                            val mapi :
                              'a t -> f:(key:label -> data:'-> 'b) -> 'b t
                            val fold :
                              'a t ->
                              init:'->
                              f:(key:label -> data:'-> '-> 'b) -> 'b
                            val fold_right :
                              'a t ->
                              init:'->
                              f:(key:label -> data:'-> '-> 'b) -> 'b
                            val fold2 :
                              'a t ->
                              'b t ->
                              init:'->
                              f:(key:label ->
                                 data:[ `Both of 'a * 'b
                                      | `Left of 'a
                                      | `Right of 'b ] ->
                                 '-> 'c) ->
                              'c
                            val filter_keys :
                              'a t -> f:(label -> bool) -> 'a t
                            val filter : 'a t -> f:('-> bool) -> 'a t
                            val filteri :
                              'a t ->
                              f:(key:label -> data:'-> bool) -> 'a t
                            val filter_map :
                              'a t -> f:('-> 'b option) -> 'b t
                            val filter_mapi :
                              'a t ->
                              f:(key:label -> data:'-> 'b option) -> 'b t
                            val partition_mapi :
                              'a t ->
                              f:(key:label ->
                                 data:'-> [ `Fst of '| `Snd of 'c ]) ->
                              'b t * 'c t
                            val partition_map :
                              'a t ->
                              f:('-> [ `Fst of '| `Snd of 'c ]) ->
                              'b t * 'c t
                            val partitioni_tf :
                              'a t ->
                              f:(key:label -> data:'-> bool) -> 'a t * 'a t
                            val partition_tf :
                              'a t -> f:('-> bool) -> 'a t * 'a t
                            val compare_direct :
                              ('-> '-> int) -> 'a t -> 'a t -> int
                            val equal :
                              ('-> '-> bool) -> 'a t -> 'a t -> bool
                            val keys : 'a t -> label list
                            val data : 'a t -> 'a list
                            val to_alist :
                              ?key_order:[ `Decreasing | `Increasing ] ->
                              'a t -> (label * 'a) list
                            val validate :
                              name:(label -> string) ->
                              'Base__.Validate.check ->
                              'a t Base__.Validate.check
                            val merge :
                              'a t ->
                              'b t ->
                              f:(key:label ->
                                 [ `Both of 'a * 'b
                                 | `Left of 'a
                                 | `Right of 'b ] -> 'c option) ->
                              'c t
                            val symmetric_diff :
                              'a t ->
                              'a t ->
                              data_equal:('-> '-> bool) ->
                              (label, 'a)
                              Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                              Base__.Sequence.t
                            val min_elt : 'a t -> (label * 'a) option
                            val min_elt_exn : 'a t -> label * 'a
                            val max_elt : 'a t -> (label * 'a) option
                            val max_elt_exn : 'a t -> label * 'a
                            val for_all : 'a t -> f:('-> bool) -> bool
                            val for_alli :
                              'a t ->
                              f:(key:label -> data:'-> bool) -> bool
                            val exists : 'a t -> f:('-> bool) -> bool
                            val existsi :
                              'a t ->
                              f:(key:label -> data:'-> bool) -> bool
                            val count : 'a t -> f:('-> bool) -> int
                            val counti :
                              'a t -> f:(key:label -> data:'-> bool) -> int
                            val split :
                              'a t ->
                              label -> 'a t * (label * 'a) option * 'a t
                            val append :
                              lower_part:'a t ->
                              upper_part:'a t ->
                              [ `Ok of 'a t | `Overlapping_key_ranges ]
                            val subrange :
                              'a t ->
                              lower_bound:label Base__.Maybe_bound.t ->
                              upper_bound:label Base__.Maybe_bound.t -> 'a t
                            val fold_range_inclusive :
                              'a t ->
                              min:label ->
                              max:label ->
                              init:'->
                              f:(key:label -> data:'-> '-> 'b) -> 'b
                            val range_to_alist :
                              'a t ->
                              min:label -> max:label -> (label * 'a) list
                            val closest_key :
                              'a t ->
                              [ `Greater_or_equal_to
                              | `Greater_than
                              | `Less_or_equal_to
                              | `Less_than ] -> label -> (label * 'a) option
                            val nth : 'a t -> int -> (label * 'a) option
                            val nth_exn : 'a t -> int -> label * 'a
                            val rank : 'a t -> label -> int option
                            val to_tree : 'a t -> 'a t
                            val to_sequence :
                              ?order:[ `Decreasing_key | `Increasing_key ] ->
                              ?keys_greater_or_equal_to:label ->
                              ?keys_less_or_equal_to:label ->
                              'a t -> (label * 'a) Base__.Sequence.t
                            val obs :
                              label Core_kernel__.Quickcheck.Observer.t ->
                              'Core_kernel__.Quickcheck.Observer.t ->
                              'v t Core_kernel__.Quickcheck.Observer.t
                            val shrinker :
                              label Core_kernel__.Quickcheck.Shrinker.t ->
                              'Core_kernel__.Quickcheck.Shrinker.t ->
                              'v t Core_kernel__.Quickcheck.Shrinker.t
                            module Provide_of_sexp :
                              functor
                                (K : sig
                                       val t_of_sexp :
                                         Sexplib.Sexp.t -> label
                                     end->
                                sig
                                  val t_of_sexp :
                                    (Sexplib.Sexp.t -> 'v_x__017_) ->
                                    Sexplib.Sexp.t -> 'v_x__017_ t
                                end
                            val t_of_sexp :
                              (Base__.Sexplib.Sexp.t -> 'a) ->
                              Base__.Sexplib.Sexp.t -> 'a t
                            val sexp_of_t :
                              ('-> Base__.Sexplib.Sexp.t) ->
                              'a t -> Base__.Sexplib.Sexp.t
                          end
                        type 'a t =
                            (label, 'a, comparator_witness)
                            Core_kernel__.Core_map_intf.Map.t
                        val compare :
                          ('-> '-> Core_kernel__.Import.int) ->
                          'a t -> 'a t -> Core_kernel__.Import.int
                        val empty : 'a t
                        val singleton : label -> '-> 'a t
                        val of_alist :
                          (label * 'a) list ->
                          [ `Duplicate_key of label | `Ok of 'a t ]
                        val of_alist_or_error :
                          (label * 'a) list -> 'a t Base__.Or_error.t
                        val of_alist_exn : (label * 'a) list -> 'a t
                        val of_alist_multi : (label * 'a) list -> 'a list t
                        val of_alist_fold :
                          (label * 'a) list ->
                          init:'-> f:('-> '-> 'b) -> 'b t
                        val of_alist_reduce :
                          (label * 'a) list -> f:('-> '-> 'a) -> 'a t
                        val of_sorted_array :
                          (label * 'a) array -> 'a t Base__.Or_error.t
                        val of_sorted_array_unchecked :
                          (label * 'a) array -> 'a t
                        val of_increasing_iterator_unchecked :
                          len:int -> f:(int -> label * 'a) -> 'a t
                        val of_iteri :
                          iteri:(f:(key:label -> data:'-> unit) -> unit) ->
                          [ `Duplicate_key of label | `Ok of 'v t ]
                        val of_tree : 'Tree.t -> 'a t
                        val of_hashtbl_exn :
                          (label, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                        val gen :
                          label Core_kernel__.Quickcheck.Generator.t ->
                          'Core_kernel__.Quickcheck.Generator.t ->
                          'a t Core_kernel__.Quickcheck.Generator.t
                        val invariants : 'a t -> bool
                        val is_empty : 'a t -> bool
                        val length : 'a t -> int
                        val add : 'a t -> key:label -> data:'-> 'a t
                        val add_multi :
                          'a list t -> key:label -> data:'-> 'a list t
                        val remove_multi : 'a list t -> label -> 'a list t
                        val change :
                          'a t -> label -> f:('a option -> 'a option) -> 'a t
                        val update :
                          'a t -> label -> f:('a option -> 'a) -> 'a t
                        val find : 'a t -> label -> 'a option
                        val find_exn : 'a t -> label -> 'a
                        val remove : 'a t -> label -> 'a t
                        val mem : 'a t -> label -> bool
                        val iter_keys : 'a t -> f:(label -> unit) -> unit
                        val iter : 'a t -> f:('-> unit) -> unit
                        val iteri :
                          'a t -> f:(key:label -> data:'-> unit) -> unit
                        val iter2 :
                          'a t ->
                          'b t ->
                          f:(key:label ->
                             data:[ `Both of 'a * 'b
                                  | `Left of 'a
                                  | `Right of 'b ] ->
                             unit) ->
                          unit
                        val map : 'a t -> f:('-> 'b) -> 'b t
                        val mapi :
                          'a t -> f:(key:label -> data:'-> 'b) -> 'b t
                        val fold :
                          'a t ->
                          init:'->
                          f:(key:label -> data:'-> '-> 'b) -> 'b
                        val fold_right :
                          'a t ->
                          init:'->
                          f:(key:label -> data:'-> '-> 'b) -> 'b
                        val fold2 :
                          'a t ->
                          'b t ->
                          init:'->
                          f:(key:label ->
                             data:[ `Both of 'a * 'b
                                  | `Left of 'a
                                  | `Right of 'b ] ->
                             '-> 'c) ->
                          'c
                        val filter_keys : 'a t -> f:(label -> bool) -> 'a t
                        val filter : 'a t -> f:('-> bool) -> 'a t
                        val filteri :
                          'a t -> f:(key:label -> data:'-> bool) -> 'a t
                        val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                        val filter_mapi :
                          'a t ->
                          f:(key:label -> data:'-> 'b option) -> 'b t
                        val partition_mapi :
                          'a t ->
                          f:(key:label ->
                             data:'-> [ `Fst of '| `Snd of 'c ]) ->
                          'b t * 'c t
                        val partition_map :
                          'a t ->
                          f:('-> [ `Fst of '| `Snd of 'c ]) ->
                          'b t * 'c t
                        val partitioni_tf :
                          'a t ->
                          f:(key:label -> data:'-> bool) -> 'a t * 'a t
                        val partition_tf :
                          'a t -> f:('-> bool) -> 'a t * 'a t
                        val compare_direct :
                          ('-> '-> int) -> 'a t -> 'a t -> int
                        val equal :
                          ('-> '-> bool) -> 'a t -> 'a t -> bool
                        val keys : 'a t -> label list
                        val data : 'a t -> 'a list
                        val to_alist :
                          ?key_order:[ `Decreasing | `Increasing ] ->
                          'a t -> (label * 'a) list
                        val validate :
                          name:(label -> string) ->
                          'Base__.Validate.check ->
                          'a t Base__.Validate.check
                        val merge :
                          'a t ->
                          'b t ->
                          f:(key:label ->
                             [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                             'c option) ->
                          'c t
                        val symmetric_diff :
                          'a t ->
                          'a t ->
                          data_equal:('-> '-> bool) ->
                          (label, 'a)
                          Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                          Base__.Sequence.t
                        val min_elt : 'a t -> (label * 'a) option
                        val min_elt_exn : 'a t -> label * 'a
                        val max_elt : 'a t -> (label * 'a) option
                        val max_elt_exn : 'a t -> label * 'a
                        val for_all : 'a t -> f:('-> bool) -> bool
                        val for_alli :
                          'a t -> f:(key:label -> data:'-> bool) -> bool
                        val exists : 'a t -> f:('-> bool) -> bool
                        val existsi :
                          'a t -> f:(key:label -> data:'-> bool) -> bool
                        val count : 'a t -> f:('-> bool) -> int
                        val counti :
                          'a t -> f:(key:label -> data:'-> bool) -> int
                        val split :
                          'a t -> label -> 'a t * (label * 'a) option * 'a t
                        val append :
                          lower_part:'a t ->
                          upper_part:'a t ->
                          [ `Ok of 'a t | `Overlapping_key_ranges ]
                        val subrange :
                          'a t ->
                          lower_bound:label Base__.Maybe_bound.t ->
                          upper_bound:label Base__.Maybe_bound.t -> 'a t
                        val fold_range_inclusive :
                          'a t ->
                          min:label ->
                          max:label ->
                          init:'->
                          f:(key:label -> data:'-> '-> 'b) -> 'b
                        val range_to_alist :
                          'a t -> min:label -> max:label -> (label * 'a) list
                        val closest_key :
                          'a t ->
                          [ `Greater_or_equal_to
                          | `Greater_than
                          | `Less_or_equal_to
                          | `Less_than ] -> label -> (label * 'a) option
                        val nth : 'a t -> int -> (label * 'a) option
                        val nth_exn : 'a t -> int -> label * 'a
                        val rank : 'a t -> label -> int option
                        val to_tree : 'a t -> 'Tree.t
                        val to_sequence :
                          ?order:[ `Decreasing_key | `Increasing_key ] ->
                          ?keys_greater_or_equal_to:label ->
                          ?keys_less_or_equal_to:label ->
                          'a t -> (label * 'a) Base__.Sequence.t
                        val obs :
                          label Core_kernel__.Quickcheck.Observer.t ->
                          'Core_kernel__.Quickcheck.Observer.t ->
                          'v t Core_kernel__.Quickcheck.Observer.t
                        val shrinker :
                          label Core_kernel__.Quickcheck.Shrinker.t ->
                          'Core_kernel__.Quickcheck.Shrinker.t ->
                          'v t Core_kernel__.Quickcheck.Shrinker.t
                        module Provide_of_sexp :
                          functor
                            (Key : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> label
                                   end->
                            sig
                              val t_of_sexp :
                                (Sexplib.Sexp.t -> 'v_x__018_) ->
                                Sexplib.Sexp.t -> 'v_x__018_ t
                            end
                        module Provide_bin_io :
                          functor
                            (Key : sig
                                     val bin_t : label Bin_prot.Type_class.t
                                     val bin_read_t :
                                       label Bin_prot.Read.reader
                                     val __bin_read_t__ :
                                       (Core_kernel__.Import.int -> label)
                                       Bin_prot.Read.reader
                                     val bin_reader_t :
                                       label Bin_prot.Type_class.reader
                                     val bin_size_t :
                                       label Bin_prot.Size.sizer
                                     val bin_write_t :
                                       label Bin_prot.Write.writer
                                     val bin_writer_t :
                                       label Bin_prot.Type_class.writer
                                     val bin_shape_t : Bin_prot.Shape.t
                                   end->
                            sig
                              val bin_shape_t :
                                Bin_prot.Shape.t -> Bin_prot.Shape.t
                              val bin_size_t :
                                ('a, 'a t) Bin_prot.Size.sizer1
                              val bin_write_t :
                                ('a, 'a t) Bin_prot.Write.writer1
                              val bin_read_t :
                                ('a, 'a t) Bin_prot.Read.reader1
                              val __bin_read_t__ :
                                ('a, int -> 'a t) Bin_prot.Read.reader1
                              val bin_writer_t :
                                ('a, 'a t) Bin_prot.Type_class.S1.writer
                              val bin_reader_t :
                                ('a, 'a t) Bin_prot.Type_class.S1.reader
                              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                            end
                        module Provide_hash :
                          functor
                            (Key : sig
                                     val hash_fold_t :
                                       Base__.Hash.state ->
                                       label -> Base__.Hash.state
                                   end->
                            sig
                              val hash_fold_t :
                                (Ppx_hash_lib.Std.Hash.state ->
                                 '-> Ppx_hash_lib.Std.Hash.state) ->
                                Ppx_hash_lib.Std.Hash.state ->
                                'a t -> Ppx_hash_lib.Std.Hash.state
                            end
                        val t_of_sexp :
                          (Base__.Sexplib.Sexp.t -> 'a) ->
                          Base__.Sexplib.Sexp.t -> 'a t
                        val sexp_of_t :
                          ('-> Base__.Sexplib.Sexp.t) ->
                          'a t -> Base__.Sexplib.Sexp.t
                      end
                    module Set :
                      sig
                        module Elt :
                          sig
                            type t = label
                            val t_of_sexp : Sexplib.Sexp.t -> t
                            val sexp_of_t : t -> Sexplib.Sexp.t
                            type comparator_witness =
                                Map.Key.comparator_witness
                            val comparator :
                              (t, comparator_witness)
                              Core_kernel__.Comparator.comparator
                          end
                        module Tree :
                          sig
                            type t =
                                (label, comparator_witness)
                                Core_kernel__.Core_set_intf.Tree.t
                            val compare : t -> t -> Core_kernel__.Import.int
                            val length : t -> int
                            val is_empty : t -> bool
                            val iter : t -> f:(label -> unit) -> unit
                            val fold :
                              t ->
                              init:'accum ->
                              f:('accum -> label -> 'accum) -> 'accum
                            val fold_result :
                              t ->
                              init:'accum ->
                              f:('accum ->
                                 label -> ('accum, 'e) Base__.Result.t) ->
                              ('accum, 'e) Base__.Result.t
                            val exists : t -> f:(label -> bool) -> bool
                            val for_all : t -> f:(label -> bool) -> bool
                            val count : t -> f:(label -> bool) -> int
                            val sum :
                              (module Base__.Commutative_group.S with type t = 'sum) ->
                              t -> f:(label -> 'sum) -> 'sum
                            val find : t -> f:(label -> bool) -> label option
                            val find_map :
                              t -> f:(label -> 'a option) -> 'a option
                            val to_list : t -> label list
                            val to_array : t -> label array
                            val invariants : t -> bool
                            val mem : t -> label -> bool
                            val add : t -> label -> t
                            val remove : t -> label -> t
                            val union : t -> t -> t
                            val inter : t -> t -> t
                            val diff : t -> t -> t
                            val symmetric_diff :
                              t ->
                              t ->
                              (label, label) Base__.Either.t
                              Base__.Sequence.t
                            val compare_direct : t -> t -> int
                            val equal : t -> t -> bool
                            val is_subset : t -> of_:t -> bool
                            val subset : t -> t -> bool
                            val fold_until :
                              t ->
                              init:'->
                              f:('->
                                 label ->
                                 ('b, 'stop)
                                 Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                              ('b, 'stop)
                              Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                            val fold_right :
                              t -> init:'-> f:(label -> '-> 'b) -> 'b
                            val iter2 :
                              t ->
                              t ->
                              f:([ `Both of label * label
                                 | `Left of label
                                 | `Right of label ] -> unit) ->
                              unit
                            val filter : t -> f:(label -> bool) -> t
                            val partition_tf :
                              t -> f:(label -> bool) -> t * t
                            val elements : t -> label list
                            val min_elt : t -> label option
                            val min_elt_exn : t -> label
                            val max_elt : t -> label option
                            val max_elt_exn : t -> label
                            val choose : t -> label option
                            val choose_exn : t -> label
                            val split : t -> label -> t * label option * t
                            val group_by :
                              t -> equiv:(label -> label -> bool) -> t list
                            val find_exn : t -> f:(label -> bool) -> label
                            val find_index : t -> int -> label option
                            val nth : t -> int -> label option
                            val remove_index : t -> int -> t
                            val to_tree : t -> t
                            val to_sequence :
                              ?order:[ `Decreasing | `Increasing ] ->
                              ?greater_or_equal_to:label ->
                              ?less_or_equal_to:label ->
                              t -> label Base__.Sequence.t
                            val merge_to_sequence :
                              ?order:[ `Decreasing | `Increasing ] ->
                              ?greater_or_equal_to:label ->
                              ?less_or_equal_to:label ->
                              t ->
                              t ->
                              (label, label)
                              Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                              Base__.Sequence.t
                            val to_map :
                              t ->
                              f:(label -> 'data) ->
                              (label, 'data, comparator_witness)
                              Core_kernel__.Core_set_intf.Map.t
                            val obs :
                              label Core_kernel__.Quickcheck.Observer.t ->
                              t Core_kernel__.Quickcheck.Observer.t
                            val shrinker :
                              label Core_kernel__.Quickcheck.Shrinker.t ->
                              t Core_kernel__.Quickcheck.Shrinker.t
                            val empty : t
                            val singleton : label -> t
                            val union_list : t list -> t
                            val of_list : label list -> t
                            val of_array : label array -> t
                            val of_sorted_array :
                              label array -> t Base__.Or_error.t
                            val of_sorted_array_unchecked : label array -> t
                            val of_increasing_iterator_unchecked :
                              len:int -> f:(int -> label) -> t
                            val stable_dedup_list : label list -> label list
                            val map :
                              ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                              f:('-> label) -> t
                            val filter_map :
                              ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                              f:('-> label option) -> t
                            val of_tree : t -> t
                            val of_hash_set :
                              label Core_kernel__.Hash_set.t -> t
                            val of_hashtbl_keys :
                              (label, 'a) Core_kernel__.Core_hashtbl.t -> t
                            val of_map_keys :
                              (label, 'a, comparator_witness)
                              Core_kernel__.Core_set_intf.Map.t -> t
                            val gen :
                              label Core_kernel__.Quickcheck.Generator.t ->
                              t Core_kernel__.Quickcheck.Generator.t
                            module Provide_of_sexp :
                              functor
                                (Elt : sig
                                         val t_of_sexp :
                                           Sexplib.Sexp.t -> label
                                       end->
                                sig val t_of_sexp : Sexplib.Sexp.t -> t end
                            val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                            val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                          end
                        type t = (label, comparator_witness) Base.Set.t
                        val compare : t -> t -> Core_kernel__.Import.int
                        val length : t -> int
                        val is_empty : t -> bool
                        val iter : t -> f:(label -> unit) -> unit
                        val fold :
                          t ->
                          init:'accum ->
                          f:('accum -> label -> 'accum) -> 'accum
                        val fold_result :
                          t ->
                          init:'accum ->
                          f:('accum -> label -> ('accum, 'e) Base__.Result.t) ->
                          ('accum, 'e) Base__.Result.t
                        val exists : t -> f:(label -> bool) -> bool
                        val for_all : t -> f:(label -> bool) -> bool
                        val count : t -> f:(label -> bool) -> int
                        val sum :
                          (module Base__.Commutative_group.S with type t = 'sum) ->
                          t -> f:(label -> 'sum) -> 'sum
                        val find : t -> f:(label -> bool) -> label option
                        val find_map :
                          t -> f:(label -> 'a option) -> 'a option
                        val to_list : t -> label list
                        val to_array : t -> label array
                        val invariants : t -> bool
                        val mem : t -> label -> bool
                        val add : t -> label -> t
                        val remove : t -> label -> t
                        val union : t -> t -> t
                        val inter : t -> t -> t
                        val diff : t -> t -> t
                        val symmetric_diff :
                          t ->
                          t ->
                          (label, label) Base__.Either.t Base__.Sequence.t
                        val compare_direct : t -> t -> int
                        val equal : t -> t -> bool
                        val is_subset : t -> of_:t -> bool
                        val subset : t -> t -> bool
                        val fold_until :
                          t ->
                          init:'->
                          f:('->
                             label ->
                             ('b, 'stop)
                             Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                          ('b, 'stop)
                          Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                        val fold_right :
                          t -> init:'-> f:(label -> '-> 'b) -> 'b
                        val iter2 :
                          t ->
                          t ->
                          f:([ `Both of label * label
                             | `Left of label
                             | `Right of label ] -> unit) ->
                          unit
                        val filter : t -> f:(label -> bool) -> t
                        val partition_tf : t -> f:(label -> bool) -> t * t
                        val elements : t -> label list
                        val min_elt : t -> label option
                        val min_elt_exn : t -> label
                        val max_elt : t -> label option
                        val max_elt_exn : t -> label
                        val choose : t -> label option
                        val choose_exn : t -> label
                        val split : t -> label -> t * label option * t
                        val group_by :
                          t -> equiv:(label -> label -> bool) -> t list
                        val find_exn : t -> f:(label -> bool) -> label
                        val find_index : t -> int -> label option
                        val nth : t -> int -> label option
                        val remove_index : t -> int -> t
                        val to_tree : t -> Tree.t
                        val to_sequence :
                          ?order:[ `Decreasing | `Increasing ] ->
                          ?greater_or_equal_to:label ->
                          ?less_or_equal_to:label ->
                          t -> label Base__.Sequence.t
                        val merge_to_sequence :
                          ?order:[ `Decreasing | `Increasing ] ->
                          ?greater_or_equal_to:label ->
                          ?less_or_equal_to:label ->
                          t ->
                          t ->
                          (label, label)
                          Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                          Base__.Sequence.t
                        val to_map :
                          t ->
                          f:(label -> 'data) ->
                          (label, 'data, comparator_witness)
                          Core_kernel__.Core_set_intf.Map.t
                        val obs :
                          label Core_kernel__.Quickcheck.Observer.t ->
                          t Core_kernel__.Quickcheck.Observer.t
                        val shrinker :
                          label Core_kernel__.Quickcheck.Shrinker.t ->
                          t Core_kernel__.Quickcheck.Shrinker.t
                        val empty : t
                        val singleton : label -> t
                        val union_list : t list -> t
                        val of_list : label list -> t
                        val of_array : label array -> t
                        val of_sorted_array :
                          label array -> t Base__.Or_error.t
                        val of_sorted_array_unchecked : label array -> t
                        val of_increasing_iterator_unchecked :
                          len:int -> f:(int -> label) -> t
                        val stable_dedup_list : label list -> label list
                        val map : ('a, 'b) Base.Set.t -> f:('-> label) -> t
                        val filter_map :
                          ('a, 'b) Base.Set.t -> f:('-> label option) -> t
                        val of_tree : Tree.t -> t
                        val of_hash_set : label Core_kernel__.Hash_set.t -> t
                        val of_hashtbl_keys :
                          (label, 'a) Core_kernel__.Core_hashtbl.t -> t
                        val of_map_keys :
                          (label, 'a, comparator_witness)
                          Core_kernel__.Core_set_intf.Map.t -> t
                        val gen :
                          label Core_kernel__.Quickcheck.Generator.t ->
                          t Core_kernel__.Quickcheck.Generator.t
                        module Provide_of_sexp :
                          functor
                            (Elt : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> label
                                   end->
                            sig val t_of_sexp : Sexplib.Sexp.t -> t end
                        module Provide_bin_io :
                          functor
                            (Elt : sig
                                     val bin_t : label Bin_prot.Type_class.t
                                     val bin_read_t :
                                       label Bin_prot.Read.reader
                                     val __bin_read_t__ :
                                       (Core_kernel__.Import.int -> label)
                                       Bin_prot.Read.reader
                                     val bin_reader_t :
                                       label Bin_prot.Type_class.reader
                                     val bin_size_t :
                                       label Bin_prot.Size.sizer
                                     val bin_write_t :
                                       label Bin_prot.Write.writer
                                     val bin_writer_t :
                                       label Bin_prot.Type_class.writer
                                     val bin_shape_t : Bin_prot.Shape.t
                                   end->
                            sig
                              val bin_size_t : t Bin_prot.Size.sizer
                              val bin_write_t : t Bin_prot.Write.writer
                              val bin_read_t : t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                (int -> t) Bin_prot.Read.reader
                              val bin_shape_t : Bin_prot.Shape.t
                              val bin_writer_t : t Bin_prot.Type_class.writer
                              val bin_reader_t : t Bin_prot.Type_class.reader
                              val bin_t : t Bin_prot.Type_class.t
                            end
                        module Provide_hash :
                          functor
                            (Elt : sig
                                     val hash_fold_t :
                                       Base__.Hash.state ->
                                       label -> Base__.Hash.state
                                   end->
                            sig
                              val hash_fold_t :
                                Ppx_hash_lib.Std.Hash.state ->
                                t -> Ppx_hash_lib.Std.Hash.state
                              val hash :
                                t -> Ppx_hash_lib.Std.Hash.hash_value
                            end
                        val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                        val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                      end
                    val hash : label -> Core_kernel__.Import.int
                    val compare : label -> label -> Core_kernel__.Import.int
                    val hashable :
                      label Core_kernel.Std.Hashable.Hashtbl.Hashable.t
                    module Table :
                      sig
                        type key = label
                        type ('a, 'b) hashtbl = ('a, 'b) Equiv.Table.hashtbl
                        type 'b t = (key, 'b) hashtbl
                        val sexp_of_t :
                          ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                        type ('a, 'b) t_ = 'b t
                        type 'a key_ = key
                        val hashable :
                          key Core_kernel__.Core_hashtbl_intf.Hashable.t
                        val invariant :
                          'Base__.Invariant_intf.inv ->
                          'a t Base__.Invariant_intf.inv
                        val create :
                          (key, 'b, unit -> 'b t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist :
                          (key, 'b,
                           (key * 'b) list ->
                           [ `Duplicate_key of key | `Ok of 'b t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_report_all_dups :
                          (key, 'b,
                           (key * 'b) list ->
                           [ `Duplicate_keys of key list | `Ok of 'b t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_or_error :
                          (key, 'b,
                           (key * 'b) list -> 'b t Base__.Or_error.t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_exn :
                          (key, 'b, (key * 'b) list -> 'b t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_multi :
                          (key, 'b list, (key * 'b) list -> 'b list t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_mapped :
                          (key, 'b,
                           get_key:('-> key) ->
                           get_data:('-> 'b) ->
                           'r list ->
                           [ `Duplicate_keys of key list | `Ok of 'b t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_with_key :
                          (key, 'r,
                           get_key:('-> key) ->
                           'r list ->
                           [ `Duplicate_keys of key list | `Ok of 'r t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_with_key_or_error :
                          (key, 'r,
                           get_key:('-> key) ->
                           'r list -> 'r t Base__.Or_error.t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_with_key_exn :
                          (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val group :
                          (key, 'b,
                           get_key:('-> key) ->
                           get_data:('-> 'b) ->
                           combine:('-> '-> 'b) -> 'r list -> 'b t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                        val clear : 'a t -> unit
                        val copy : 'b t -> 'b t
                        val fold :
                          'b t ->
                          init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                        val iter_keys : 'a t -> f:(key -> unit) -> unit
                        val iter : 'b t -> f:('-> unit) -> unit
                        val iteri :
                          'b t -> f:(key:key -> data:'-> unit) -> unit
                        val iter_vals : 'b t -> f:('-> unit) -> unit
                        val existsi :
                          'b t -> f:(key:key -> data:'-> bool) -> bool
                        val exists : 'b t -> f:('-> bool) -> bool
                        val for_alli :
                          'b t -> f:(key:key -> data:'-> bool) -> bool
                        val for_all : 'b t -> f:('-> bool) -> bool
                        val counti :
                          'b t -> f:(key:key -> data:'-> bool) -> int
                        val count : 'b t -> f:('-> bool) -> int
                        val length : 'a t -> int
                        val is_empty : 'a t -> bool
                        val mem : 'a t -> key -> bool
                        val remove : 'a t -> key -> unit
                        val replace : 'b t -> key:key -> data:'-> unit
                        val set : 'b t -> key:key -> data:'-> unit
                        val add :
                          'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                        val add_or_error :
                          'b t ->
                          key:key -> data:'-> unit Base__.Or_error.t
                        val add_exn : 'b t -> key:key -> data:'-> unit
                        val change :
                          'b t -> key -> f:('b option -> 'b option) -> unit
                        val update :
                          'b t -> key -> f:('b option -> 'b) -> unit
                        val add_multi :
                          'b list t -> key:key -> data:'-> unit
                        val remove_multi : 'a list t -> key -> unit
                        val map : 'b t -> f:('-> 'c) -> 'c t
                        val mapi :
                          'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                        val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                        val filter_mapi :
                          'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                        val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                        val filter : 'b t -> f:('-> bool) -> 'b t
                        val filteri :
                          'b t -> f:(key:key -> data:'-> bool) -> 'b t
                        val partition_map :
                          'b t ->
                          f:('-> [ `Fst of '| `Snd of 'd ]) ->
                          'c t * 'd t
                        val partition_mapi :
                          'b t ->
                          f:(key:key ->
                             data:'-> [ `Fst of '| `Snd of 'd ]) ->
                          'c t * 'd t
                        val partition_tf :
                          'b t -> f:('-> bool) -> 'b t * 'b t
                        val partitioni_tf :
                          'b t ->
                          f:(key:key -> data:'-> bool) -> 'b t * 'b t
                        val find_or_add :
                          'b t -> key -> default:(unit -> 'b) -> 'b
                        val find : 'b t -> key -> 'b option
                        val find_exn : 'b t -> key -> 'b
                        val find_and_call :
                          'b t ->
                          key ->
                          if_found:('-> 'c) ->
                          if_not_found:(key -> 'c) -> 'c
                        val find_and_remove : 'b t -> key -> 'b option
                        val merge :
                          'a t ->
                          'b t ->
                          f:(key:key ->
                             [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                             'c option) ->
                          'c t
                        type 'a merge_into_action = Remove | Set_to of 'a
                        val merge_into :
                          src:'a t ->
                          dst:'b t ->
                          f:(key:key ->
                             '-> 'b option -> 'b merge_into_action) ->
                          unit
                        val keys : 'a t -> key list
                        val data : 'b t -> 'b list
                        val filter_keys_inplace :
                          'a t -> f:(key -> bool) -> unit
                        val filter_inplace : 'b t -> f:('-> bool) -> unit
                        val filteri_inplace :
                          'b t -> f:(key:key -> data:'-> bool) -> unit
                        val map_inplace : 'b t -> f:('-> 'b) -> unit
                        val mapi_inplace :
                          'b t -> f:(key:key -> data:'-> 'b) -> unit
                        val filter_map_inplace :
                          'b t -> f:('-> 'b option) -> unit
                        val filter_mapi_inplace :
                          'b t -> f:(key:key -> data:'-> 'b option) -> unit
                        val replace_all : 'b t -> f:('-> 'b) -> unit
                        val replace_alli :
                          'b t -> f:(key:key -> data:'-> 'b) -> unit
                        val filter_replace_all :
                          'b t -> f:('-> 'b option) -> unit
                        val filter_replace_alli :
                          'b t -> f:(key:key -> data:'-> 'b option) -> unit
                        val equal :
                          'b t -> 'b t -> ('-> '-> bool) -> bool
                        val similar :
                          'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                        val to_alist : 'b t -> (key * 'b) list
                        val validate :
                          name:(key -> string) ->
                          'Base__.Validate.check ->
                          'b t Base__.Validate.check
                        val incr :
                          ?by:int ->
                          ?remove_if_zero:bool -> int t -> key -> unit
                        val decr :
                          ?by:int ->
                          ?remove_if_zero:bool -> int t -> key -> unit
                        module Provide_of_sexp :
                          functor
                            (Key : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> key
                                   end->
                            sig
                              val t_of_sexp :
                                (Sexplib.Sexp.t -> 'v_x__001_) ->
                                Sexplib.Sexp.t -> 'v_x__001_ t
                            end
                        module Provide_bin_io :
                          functor
                            (Key : sig
                                     val bin_t : key Bin_prot.Type_class.t
                                     val bin_read_t :
                                       key Bin_prot.Read.reader
                                     val __bin_read_t__ :
                                       (Core_kernel__.Import.int -> key)
                                       Bin_prot.Read.reader
                                     val bin_reader_t :
                                       key Bin_prot.Type_class.reader
                                     val bin_size_t : key Bin_prot.Size.sizer
                                     val bin_write_t :
                                       key Bin_prot.Write.writer
                                     val bin_writer_t :
                                       key Bin_prot.Type_class.writer
                                     val bin_shape_t : Bin_prot.Shape.t
                                   end->
                            sig
                              val bin_t :
                                'Bin_prot.Type_class.t ->
                                'a t Bin_prot.Type_class.t
                              val bin_read_t :
                                'Bin_prot.Read.reader ->
                                'a t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                'Bin_prot.Read.reader ->
                                (Core_kernel__.Import.int -> 'a t)
                                Bin_prot.Read.reader
                              val bin_reader_t :
                                'Bin_prot.Type_class.reader ->
                                'a t Bin_prot.Type_class.reader
                              val bin_size_t :
                                'Bin_prot.Size.sizer ->
                                'a t Bin_prot.Size.sizer
                              val bin_write_t :
                                'Bin_prot.Write.writer ->
                                'a t Bin_prot.Write.writer
                              val bin_writer_t :
                                'Bin_prot.Type_class.writer ->
                                'a t Bin_prot.Type_class.writer
                              val bin_shape_t :
                                Bin_prot.Shape.t -> Bin_prot.Shape.t
                            end
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__002_) ->
                          Sexplib.Sexp.t -> 'v_x__002_ t
                      end
                    module Hash_set :
                      sig
                        type elt = label
                        type t = elt Core_kernel__.Hash_set.t
                        val sexp_of_t : t -> Sexplib.Sexp.t
                        type 'a t_ = t
                        type 'a elt_ = elt
                        val create :
                          ('a, unit -> t)
                          Core_kernel__.Hash_set_intf.create_options_without_hashable
                        val of_list :
                          ('a, elt list -> t)
                          Core_kernel__.Hash_set_intf.create_options_without_hashable
                        module Provide_of_sexp :
                          functor
                            (X : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> elt
                                 end->
                            sig val t_of_sexp : Sexplib.Sexp.t -> t end
                        module Provide_bin_io :
                          functor
                            (X : sig
                                   val bin_t : elt Bin_prot.Type_class.t
                                   val bin_read_t : elt Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> elt)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     elt Bin_prot.Type_class.reader
                                   val bin_size_t : elt Bin_prot.Size.sizer
                                   val bin_write_t :
                                     elt Bin_prot.Write.writer
                                   val bin_writer_t :
                                     elt Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                            sig
                              val bin_t : t Bin_prot.Type_class.t
                              val bin_read_t : t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                (Core_kernel__.Import.int -> t)
                                Bin_prot.Read.reader
                              val bin_reader_t : t Bin_prot.Type_class.reader
                              val bin_size_t : t Bin_prot.Size.sizer
                              val bin_write_t : t Bin_prot.Write.writer
                              val bin_writer_t : t Bin_prot.Type_class.writer
                              val bin_shape_t : Bin_prot.Shape.t
                            end
                        val t_of_sexp : Sexplib.Sexp.t -> t
                      end
                    module Hash_queue :
                      sig
                        module Key :
                          sig
                            type t = label
                            val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                            val compare : t -> t -> int
                            val hash : t -> int
                          end
                        type 'a t
                        val sexp_of_t :
                          ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                        val length : 'a t -> int
                        val is_empty : 'a t -> bool
                        val iter : 'a t -> f:('-> unit) -> unit
                        val fold :
                          'a t ->
                          init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                        val fold_result :
                          'a t ->
                          init:'accum ->
                          f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                          ('accum, 'e) Base__.Result.t
                        val fold_until :
                          'a t ->
                          init:'accum ->
                          f:('accum ->
                             '->
                             ('accum, 'stop)
                             Base.Container_intf.Continue_or_stop.t) ->
                          ('accum, 'stop)
                          Base.Container_intf.Finished_or_stopped_early.t
                        val exists : 'a t -> f:('-> bool) -> bool
                        val for_all : 'a t -> f:('-> bool) -> bool
                        val count : 'a t -> f:('-> bool) -> int
                        val sum :
                          (module Base__.Commutative_group.S with type t = 'sum) ->
                          'a t -> f:('-> 'sum) -> 'sum
                        val find : 'a t -> f:('-> bool) -> 'a option
                        val find_map :
                          'a t -> f:('-> 'b option) -> 'b option
                        val to_list : 'a t -> 'a list
                        val to_array : 'a t -> 'a array
                        val min_elt :
                          'a t -> cmp:('-> '-> int) -> 'a option
                        val max_elt :
                          'a t -> cmp:('-> '-> int) -> 'a option
                        val invariant : 'a t -> Core_kernel__.Import.unit
                        val create :
                          ?growth_allowed:Core_kernel__.Import.bool ->
                          ?size:Core_kernel__.Import.int ->
                          Core_kernel__.Import.unit -> 'a t
                        val clear : 'a t -> Core_kernel__.Import.unit
                        val mem : 'a t -> label -> Core_kernel__.Import.bool
                        val lookup :
                          'a t -> label -> 'Core_kernel__.Import.option
                        val lookup_exn : 'a t -> label -> 'a
                        val enqueue :
                          'a t ->
                          label -> '-> [ `Key_already_present | `Ok ]
                        val enqueue_exn :
                          'a t -> label -> '-> Core_kernel__.Import.unit
                        val lookup_and_move_to_back :
                          'a t -> label -> 'Core_kernel__.Import.option
                        val lookup_and_move_to_back_exn : 'a t -> label -> 'a
                        val first : 'a t -> 'Core_kernel__.Import.option
                        val first_with_key :
                          'a t -> (label * 'a) Core_kernel__.Import.option
                        val keys : 'a t -> label Core_kernel__.Import.list
                        val dequeue : 'a t -> 'Core_kernel__.Import.option
                        val dequeue_exn : 'a t -> 'a
                        val dequeue_with_key :
                          'a t -> (label * 'a) Core_kernel__.Import.option
                        val dequeue_with_key_exn : 'a t -> label * 'a
                        val dequeue_all :
                          'a t ->
                          f:('-> Core_kernel__.Import.unit) ->
                          Core_kernel__.Import.unit
                        val remove : 'a t -> label -> [ `No_such_key | `Ok ]
                        val remove_exn :
                          'a t -> label -> Core_kernel__.Import.unit
                        val replace :
                          'a t -> label -> '-> [ `No_such_key | `Ok ]
                        val replace_exn :
                          'a t -> label -> '-> Core_kernel__.Import.unit
                        val iteri :
                          'a t ->
                          f:(key:label ->
                             data:'-> Core_kernel__.Import.unit) ->
                          Core_kernel__.Import.unit
                        val foldi :
                          'a t ->
                          init:'->
                          f:('-> key:label -> data:'-> 'b) -> 'b
                      end
                  end
                module Edge :
                  sig
                    type t = edge
                    type node = Node.t
                    type graph = Node.graph
                    type label = Edge.t
                    val create : node -> node -> label -> t
                    val label : t -> label
                    val src : t -> node
                    val dst : t -> node
                    val mem : t -> graph -> bool
                    val insert : t -> graph -> graph
                    val update : t -> label -> graph -> graph
                    val remove : t -> graph -> graph
                    val ( >= ) : t -> t -> bool
                    val ( <= ) : t -> t -> bool
                    val ( = ) : t -> t -> bool
                    val ( > ) : t -> t -> bool
                    val ( < ) : t -> t -> bool
                    val ( <> ) : t -> t -> bool
                    val equal : t -> t -> bool
                    val min : t -> t -> t
                    val max : t -> t -> t
                    val ascending : t -> t -> int
                    val descending : t -> t -> int
                    val between : t -> low:t -> high:t -> bool
                    val clamp_exn : t -> min:t -> max:t -> t
                    val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
                    type comparator_witness
                    val comparator :
                      (t, comparator_witness) Base__.Comparator.comparator
                    val validate_lbound :
                      min:t Base__.Maybe_bound.t -> t Base__.Validate.check
                    val validate_ubound :
                      max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                    val validate_bound :
                      min:t Base__.Maybe_bound.t ->
                      max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                    module Replace_polymorphic_compare :
                      sig
                        val ( >= ) : t -> t -> bool
                        val ( <= ) : t -> t -> bool
                        val ( = ) : t -> t -> bool
                        val ( > ) : t -> t -> bool
                        val ( < ) : t -> t -> bool
                        val ( <> ) : t -> t -> bool
                        val equal : t -> t -> bool
                        val compare : t -> t -> int
                        val min : t -> t -> t
                        val max : t -> t -> t
                      end
                    module Map :
                      sig
                        module Key :
                          sig
                            type t = edge
                            val t_of_sexp : Sexplib.Sexp.t -> t
                            val sexp_of_t : t -> Sexplib.Sexp.t
                            type comparator_witness = comparator_witness
                            val comparator :
                              (t, comparator_witness)
                              Core_kernel__.Comparator.comparator
                          end
                        module Tree :
                          sig
                            type 'a t =
                                (edge, 'a, comparator_witness)
                                Core_kernel__.Core_map_intf.Tree.t
                            val empty : 'a t
                            val singleton : edge -> '-> 'a t
                            val of_alist :
                              (edge * 'a) list ->
                              [ `Duplicate_key of edge | `Ok of 'a t ]
                            val of_alist_or_error :
                              (edge * 'a) list -> 'a t Base__.Or_error.t
                            val of_alist_exn : (edge * 'a) list -> 'a t
                            val of_alist_multi :
                              (edge * 'a) list -> 'a list t
                            val of_alist_fold :
                              (edge * 'a) list ->
                              init:'-> f:('-> '-> 'b) -> 'b t
                            val of_alist_reduce :
                              (edge * 'a) list -> f:('-> '-> 'a) -> 'a t
                            val of_sorted_array :
                              (edge * 'a) array -> 'a t Base__.Or_error.t
                            val of_sorted_array_unchecked :
                              (edge * 'a) array -> 'a t
                            val of_increasing_iterator_unchecked :
                              len:int -> f:(int -> edge * 'a) -> 'a t
                            val of_iteri :
                              iteri:(f:(key:edge -> data:'-> unit) -> unit) ->
                              [ `Duplicate_key of edge | `Ok of 'v t ]
                            val of_tree : 'a t -> 'a t
                            val of_hashtbl_exn :
                              (edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                            val gen :
                              edge Core_kernel__.Quickcheck.Generator.t ->
                              'Core_kernel__.Quickcheck.Generator.t ->
                              'a t Core_kernel__.Quickcheck.Generator.t
                            val invariants : 'a t -> bool
                            val is_empty : 'a t -> bool
                            val length : 'a t -> int
                            val add : 'a t -> key:edge -> data:'-> 'a t
                            val add_multi :
                              'a list t -> key:edge -> data:'-> 'a list t
                            val remove_multi : 'a list t -> edge -> 'a list t
                            val change :
                              'a t ->
                              edge -> f:('a option -> 'a option) -> 'a t
                            val update :
                              'a t -> edge -> f:('a option -> 'a) -> 'a t
                            val find : 'a t -> edge -> 'a option
                            val find_exn : 'a t -> edge -> 'a
                            val remove : 'a t -> edge -> 'a t
                            val mem : 'a t -> edge -> bool
                            val iter_keys : 'a t -> f:(edge -> unit) -> unit
                            val iter : 'a t -> f:('-> unit) -> unit
                            val iteri :
                              'a t -> f:(key:edge -> data:'-> unit) -> unit
                            val iter2 :
                              'a t ->
                              'b t ->
                              f:(key:edge ->
                                 data:[ `Both of 'a * 'b
                                      | `Left of 'a
                                      | `Right of 'b ] ->
                                 unit) ->
                              unit
                            val map : 'a t -> f:('-> 'b) -> 'b t
                            val mapi :
                              'a t -> f:(key:edge -> data:'-> 'b) -> 'b t
                            val fold :
                              'a t ->
                              init:'->
                              f:(key:edge -> data:'-> '-> 'b) -> 'b
                            val fold_right :
                              'a t ->
                              init:'->
                              f:(key:edge -> data:'-> '-> 'b) -> 'b
                            val fold2 :
                              'a t ->
                              'b t ->
                              init:'->
                              f:(key:edge ->
                                 data:[ `Both of 'a * 'b
                                      | `Left of 'a
                                      | `Right of 'b ] ->
                                 '-> 'c) ->
                              'c
                            val filter_keys :
                              'a t -> f:(edge -> bool) -> 'a t
                            val filter : 'a t -> f:('-> bool) -> 'a t
                            val filteri :
                              'a t -> f:(key:edge -> data:'-> bool) -> 'a t
                            val filter_map :
                              'a t -> f:('-> 'b option) -> 'b t
                            val filter_mapi :
                              'a t ->
                              f:(key:edge -> data:'-> 'b option) -> 'b t
                            val partition_mapi :
                              'a t ->
                              f:(key:edge ->
                                 data:'-> [ `Fst of '| `Snd of 'c ]) ->
                              'b t * 'c t
                            val partition_map :
                              'a t ->
                              f:('-> [ `Fst of '| `Snd of 'c ]) ->
                              'b t * 'c t
                            val partitioni_tf :
                              'a t ->
                              f:(key:edge -> data:'-> bool) -> 'a t * 'a t
                            val partition_tf :
                              'a t -> f:('-> bool) -> 'a t * 'a t
                            val compare_direct :
                              ('-> '-> int) -> 'a t -> 'a t -> int
                            val equal :
                              ('-> '-> bool) -> 'a t -> 'a t -> bool
                            val keys : 'a t -> edge list
                            val data : 'a t -> 'a list
                            val to_alist :
                              ?key_order:[ `Decreasing | `Increasing ] ->
                              'a t -> (edge * 'a) list
                            val validate :
                              name:(edge -> string) ->
                              'Base__.Validate.check ->
                              'a t Base__.Validate.check
                            val merge :
                              'a t ->
                              'b t ->
                              f:(key:edge ->
                                 [ `Both of 'a * 'b
                                 | `Left of 'a
                                 | `Right of 'b ] -> 'c option) ->
                              'c t
                            val symmetric_diff :
                              'a t ->
                              'a t ->
                              data_equal:('-> '-> bool) ->
                              (edge, 'a)
                              Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                              Base__.Sequence.t
                            val min_elt : 'a t -> (edge * 'a) option
                            val min_elt_exn : 'a t -> edge * 'a
                            val max_elt : 'a t -> (edge * 'a) option
                            val max_elt_exn : 'a t -> edge * 'a
                            val for_all : 'a t -> f:('-> bool) -> bool
                            val for_alli :
                              'a t -> f:(key:edge -> data:'-> bool) -> bool
                            val exists : 'a t -> f:('-> bool) -> bool
                            val existsi :
                              'a t -> f:(key:edge -> data:'-> bool) -> bool
                            val count : 'a t -> f:('-> bool) -> int
                            val counti :
                              'a t -> f:(key:edge -> data:'-> bool) -> int
                            val split :
                              'a t ->
                              edge -> 'a t * (edge * 'a) option * 'a t
                            val append :
                              lower_part:'a t ->
                              upper_part:'a t ->
                              [ `Ok of 'a t | `Overlapping_key_ranges ]
                            val subrange :
                              'a t ->
                              lower_bound:edge Base__.Maybe_bound.t ->
                              upper_bound:edge Base__.Maybe_bound.t -> 'a t
                            val fold_range_inclusive :
                              'a t ->
                              min:edge ->
                              max:edge ->
                              init:'->
                              f:(key:edge -> data:'-> '-> 'b) -> 'b
                            val range_to_alist :
                              'a t ->
                              min:edge -> max:edge -> (edge * 'a) list
                            val closest_key :
                              'a t ->
                              [ `Greater_or_equal_to
                              | `Greater_than
                              | `Less_or_equal_to
                              | `Less_than ] -> edge -> (edge * 'a) option
                            val nth : 'a t -> int -> (edge * 'a) option
                            val nth_exn : 'a t -> int -> edge * 'a
                            val rank : 'a t -> edge -> int option
                            val to_tree : 'a t -> 'a t
                            val to_sequence :
                              ?order:[ `Decreasing_key | `Increasing_key ] ->
                              ?keys_greater_or_equal_to:edge ->
                              ?keys_less_or_equal_to:edge ->
                              'a t -> (edge * 'a) Base__.Sequence.t
                            val obs :
                              edge Core_kernel__.Quickcheck.Observer.t ->
                              'Core_kernel__.Quickcheck.Observer.t ->
                              'v t Core_kernel__.Quickcheck.Observer.t
                            val shrinker :
                              edge Core_kernel__.Quickcheck.Shrinker.t ->
                              'Core_kernel__.Quickcheck.Shrinker.t ->
                              'v t Core_kernel__.Quickcheck.Shrinker.t
                            module Provide_of_sexp :
                              functor
                                (K : sig
                                       val t_of_sexp : Sexplib.Sexp.t -> edge
                                     end->
                                sig
                                  val t_of_sexp :
                                    (Sexplib.Sexp.t -> 'v_x__017_) ->
                                    Sexplib.Sexp.t -> 'v_x__017_ t
                                end
                            val t_of_sexp :
                              (Base__.Sexplib.Sexp.t -> 'a) ->
                              Base__.Sexplib.Sexp.t -> 'a t
                            val sexp_of_t :
                              ('-> Base__.Sexplib.Sexp.t) ->
                              'a t -> Base__.Sexplib.Sexp.t
                          end
                        type 'a t =
                            (edge, 'a, comparator_witness)
                            Core_kernel__.Core_map_intf.Map.t
                        val compare :
                          ('-> '-> Core_kernel__.Import.int) ->
                          'a t -> 'a t -> Core_kernel__.Import.int
                        val empty : 'a t
                        val singleton : edge -> '-> 'a t
                        val of_alist :
                          (edge * 'a) list ->
                          [ `Duplicate_key of edge | `Ok of 'a t ]
                        val of_alist_or_error :
                          (edge * 'a) list -> 'a t Base__.Or_error.t
                        val of_alist_exn : (edge * 'a) list -> 'a t
                        val of_alist_multi : (edge * 'a) list -> 'a list t
                        val of_alist_fold :
                          (edge * 'a) list ->
                          init:'-> f:('-> '-> 'b) -> 'b t
                        val of_alist_reduce :
                          (edge * 'a) list -> f:('-> '-> 'a) -> 'a t
                        val of_sorted_array :
                          (edge * 'a) array -> 'a t Base__.Or_error.t
                        val of_sorted_array_unchecked :
                          (edge * 'a) array -> 'a t
                        val of_increasing_iterator_unchecked :
                          len:int -> f:(int -> edge * 'a) -> 'a t
                        val of_iteri :
                          iteri:(f:(key:edge -> data:'-> unit) -> unit) ->
                          [ `Duplicate_key of edge | `Ok of 'v t ]
                        val of_tree : 'Tree.t -> 'a t
                        val of_hashtbl_exn :
                          (edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                        val gen :
                          edge Core_kernel__.Quickcheck.Generator.t ->
                          'Core_kernel__.Quickcheck.Generator.t ->
                          'a t Core_kernel__.Quickcheck.Generator.t
                        val invariants : 'a t -> bool
                        val is_empty : 'a t -> bool
                        val length : 'a t -> int
                        val add : 'a t -> key:edge -> data:'-> 'a t
                        val add_multi :
                          'a list t -> key:edge -> data:'-> 'a list t
                        val remove_multi : 'a list t -> edge -> 'a list t
                        val change :
                          'a t -> edge -> f:('a option -> 'a option) -> 'a t
                        val update :
                          'a t -> edge -> f:('a option -> 'a) -> 'a t
                        val find : 'a t -> edge -> 'a option
                        val find_exn : 'a t -> edge -> 'a
                        val remove : 'a t -> edge -> 'a t
                        val mem : 'a t -> edge -> bool
                        val iter_keys : 'a t -> f:(edge -> unit) -> unit
                        val iter : 'a t -> f:('-> unit) -> unit
                        val iteri :
                          'a t -> f:(key:edge -> data:'-> unit) -> unit
                        val iter2 :
                          'a t ->
                          'b t ->
                          f:(key:edge ->
                             data:[ `Both of 'a * 'b
                                  | `Left of 'a
                                  | `Right of 'b ] ->
                             unit) ->
                          unit
                        val map : 'a t -> f:('-> 'b) -> 'b t
                        val mapi :
                          'a t -> f:(key:edge -> data:'-> 'b) -> 'b t
                        val fold :
                          'a t ->
                          init:'->
                          f:(key:edge -> data:'-> '-> 'b) -> 'b
                        val fold_right :
                          'a t ->
                          init:'->
                          f:(key:edge -> data:'-> '-> 'b) -> 'b
                        val fold2 :
                          'a t ->
                          'b t ->
                          init:'->
                          f:(key:edge ->
                             data:[ `Both of 'a * 'b
                                  | `Left of 'a
                                  | `Right of 'b ] ->
                             '-> 'c) ->
                          'c
                        val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
                        val filter : 'a t -> f:('-> bool) -> 'a t
                        val filteri :
                          'a t -> f:(key:edge -> data:'-> bool) -> 'a t
                        val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                        val filter_mapi :
                          'a t ->
                          f:(key:edge -> data:'-> 'b option) -> 'b t
                        val partition_mapi :
                          'a t ->
                          f:(key:edge ->
                             data:'-> [ `Fst of '| `Snd of 'c ]) ->
                          'b t * 'c t
                        val partition_map :
                          'a t ->
                          f:('-> [ `Fst of '| `Snd of 'c ]) ->
                          'b t * 'c t
                        val partitioni_tf :
                          'a t ->
                          f:(key:edge -> data:'-> bool) -> 'a t * 'a t
                        val partition_tf :
                          'a t -> f:('-> bool) -> 'a t * 'a t
                        val compare_direct :
                          ('-> '-> int) -> 'a t -> 'a t -> int
                        val equal :
                          ('-> '-> bool) -> 'a t -> 'a t -> bool
                        val keys : 'a t -> edge list
                        val data : 'a t -> 'a list
                        val to_alist :
                          ?key_order:[ `Decreasing | `Increasing ] ->
                          'a t -> (edge * 'a) list
                        val validate :
                          name:(edge -> string) ->
                          'Base__.Validate.check ->
                          'a t Base__.Validate.check
                        val merge :
                          'a t ->
                          'b t ->
                          f:(key:edge ->
                             [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                             'c option) ->
                          'c t
                        val symmetric_diff :
                          'a t ->
                          'a t ->
                          data_equal:('-> '-> bool) ->
                          (edge, 'a)
                          Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                          Base__.Sequence.t
                        val min_elt : 'a t -> (edge * 'a) option
                        val min_elt_exn : 'a t -> edge * 'a
                        val max_elt : 'a t -> (edge * 'a) option
                        val max_elt_exn : 'a t -> edge * 'a
                        val for_all : 'a t -> f:('-> bool) -> bool
                        val for_alli :
                          'a t -> f:(key:edge -> data:'-> bool) -> bool
                        val exists : 'a t -> f:('-> bool) -> bool
                        val existsi :
                          'a t -> f:(key:edge -> data:'-> bool) -> bool
                        val count : 'a t -> f:('-> bool) -> int
                        val counti :
                          'a t -> f:(key:edge -> data:'-> bool) -> int
                        val split :
                          'a t -> edge -> 'a t * (edge * 'a) option * 'a t
                        val append :
                          lower_part:'a t ->
                          upper_part:'a t ->
                          [ `Ok of 'a t | `Overlapping_key_ranges ]
                        val subrange :
                          'a t ->
                          lower_bound:edge Base__.Maybe_bound.t ->
                          upper_bound:edge Base__.Maybe_bound.t -> 'a t
                        val fold_range_inclusive :
                          'a t ->
                          min:edge ->
                          max:edge ->
                          init:'->
                          f:(key:edge -> data:'-> '-> 'b) -> 'b
                        val range_to_alist :
                          'a t -> min:edge -> max:edge -> (edge * 'a) list
                        val closest_key :
                          'a t ->
                          [ `Greater_or_equal_to
                          | `Greater_than
                          | `Less_or_equal_to
                          | `Less_than ] -> edge -> (edge * 'a) option
                        val nth : 'a t -> int -> (edge * 'a) option
                        val nth_exn : 'a t -> int -> edge * 'a
                        val rank : 'a t -> edge -> int option
                        val to_tree : 'a t -> 'Tree.t
                        val to_sequence :
                          ?order:[ `Decreasing_key | `Increasing_key ] ->
                          ?keys_greater_or_equal_to:edge ->
                          ?keys_less_or_equal_to:edge ->
                          'a t -> (edge * 'a) Base__.Sequence.t
                        val obs :
                          edge Core_kernel__.Quickcheck.Observer.t ->
                          'Core_kernel__.Quickcheck.Observer.t ->
                          'v t Core_kernel__.Quickcheck.Observer.t
                        val shrinker :
                          edge Core_kernel__.Quickcheck.Shrinker.t ->
                          'Core_kernel__.Quickcheck.Shrinker.t ->
                          'v t Core_kernel__.Quickcheck.Shrinker.t
                        module Provide_of_sexp :
                          functor
                            (Key : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> edge
                                   end->
                            sig
                              val t_of_sexp :
                                (Sexplib.Sexp.t -> 'v_x__018_) ->
                                Sexplib.Sexp.t -> 'v_x__018_ t
                            end
                        module Provide_bin_io :
                          functor
                            (Key : sig
                                     val bin_t : edge Bin_prot.Type_class.t
                                     val bin_read_t :
                                       edge Bin_prot.Read.reader
                                     val __bin_read_t__ :
                                       (Core_kernel__.Import.int -> edge)
                                       Bin_prot.Read.reader
                                     val bin_reader_t :
                                       edge Bin_prot.Type_class.reader
                                     val bin_size_t :
                                       edge Bin_prot.Size.sizer
                                     val bin_write_t :
                                       edge Bin_prot.Write.writer
                                     val bin_writer_t :
                                       edge Bin_prot.Type_class.writer
                                     val bin_shape_t : Bin_prot.Shape.t
                                   end->
                            sig
                              val bin_shape_t :
                                Bin_prot.Shape.t -> Bin_prot.Shape.t
                              val bin_size_t :
                                ('a, 'a t) Bin_prot.Size.sizer1
                              val bin_write_t :
                                ('a, 'a t) Bin_prot.Write.writer1
                              val bin_read_t :
                                ('a, 'a t) Bin_prot.Read.reader1
                              val __bin_read_t__ :
                                ('a, int -> 'a t) Bin_prot.Read.reader1
                              val bin_writer_t :
                                ('a, 'a t) Bin_prot.Type_class.S1.writer
                              val bin_reader_t :
                                ('a, 'a t) Bin_prot.Type_class.S1.reader
                              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                            end
                        module Provide_hash :
                          functor
                            (Key : sig
                                     val hash_fold_t :
                                       Base__.Hash.state ->
                                       edge -> Base__.Hash.state
                                   end->
                            sig
                              val hash_fold_t :
                                (Ppx_hash_lib.Std.Hash.state ->
                                 '-> Ppx_hash_lib.Std.Hash.state) ->
                                Ppx_hash_lib.Std.Hash.state ->
                                'a t -> Ppx_hash_lib.Std.Hash.state
                            end
                        val t_of_sexp :
                          (Base__.Sexplib.Sexp.t -> 'a) ->
                          Base__.Sexplib.Sexp.t -> 'a t
                        val sexp_of_t :
                          ('-> Base__.Sexplib.Sexp.t) ->
                          'a t -> Base__.Sexplib.Sexp.t
                      end
                    module Set :
                      sig
                        module Elt :
                          sig
                            type t = edge
                            val t_of_sexp : Sexplib.Sexp.t -> t
                            val sexp_of_t : t -> Sexplib.Sexp.t
                            type comparator_witness =
                                Map.Key.comparator_witness
                            val comparator :
                              (t, comparator_witness)
                              Core_kernel__.Comparator.comparator
                          end
                        module Tree :
                          sig
                            type t =
                                (edge, comparator_witness)
                                Core_kernel__.Core_set_intf.Tree.t
                            val compare : t -> t -> Core_kernel__.Import.int
                            val length : t -> int
                            val is_empty : t -> bool
                            val iter : t -> f:(edge -> unit) -> unit
                            val fold :
                              t ->
                              init:'accum ->
                              f:('accum -> edge -> 'accum) -> 'accum
                            val fold_result :
                              t ->
                              init:'accum ->
                              f:('accum ->
                                 edge -> ('accum, 'e) Base__.Result.t) ->
                              ('accum, 'e) Base__.Result.t
                            val exists : t -> f:(edge -> bool) -> bool
                            val for_all : t -> f:(edge -> bool) -> bool
                            val count : t -> f:(edge -> bool) -> int
                            val sum :
                              (module Base__.Commutative_group.S with type t = 'sum) ->
                              t -> f:(edge -> 'sum) -> 'sum
                            val find : t -> f:(edge -> bool) -> edge option
                            val find_map :
                              t -> f:(edge -> 'a option) -> 'a option
                            val to_list : t -> edge list
                            val to_array : t -> edge array
                            val invariants : t -> bool
                            val mem : t -> edge -> bool
                            val add : t -> edge -> t
                            val remove : t -> edge -> t
                            val union : t -> t -> t
                            val inter : t -> t -> t
                            val diff : t -> t -> t
                            val symmetric_diff :
                              t ->
                              t ->
                              (edge, edge) Base__.Either.t Base__.Sequence.t
                            val compare_direct : t -> t -> int
                            val equal : t -> t -> bool
                            val is_subset : t -> of_:t -> bool
                            val subset : t -> t -> bool
                            val fold_until :
                              t ->
                              init:'->
                              f:('->
                                 edge ->
                                 ('b, 'stop)
                                 Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                              ('b, 'stop)
                              Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                            val fold_right :
                              t -> init:'-> f:(edge -> '-> 'b) -> 'b
                            val iter2 :
                              t ->
                              t ->
                              f:([ `Both of edge * edge
                                 | `Left of edge
                                 | `Right of edge ] -> unit) ->
                              unit
                            val filter : t -> f:(edge -> bool) -> t
                            val partition_tf : t -> f:(edge -> bool) -> t * t
                            val elements : t -> edge list
                            val min_elt : t -> edge option
                            val min_elt_exn : t -> edge
                            val max_elt : t -> edge option
                            val max_elt_exn : t -> edge
                            val choose : t -> edge option
                            val choose_exn : t -> edge
                            val split : t -> edge -> t * edge option * t
                            val group_by :
                              t -> equiv:(edge -> edge -> bool) -> t list
                            val find_exn : t -> f:(edge -> bool) -> edge
                            val find_index : t -> int -> edge option
                            val nth : t -> int -> edge option
                            val remove_index : t -> int -> t
                            val to_tree : t -> t
                            val to_sequence :
                              ?order:[ `Decreasing | `Increasing ] ->
                              ?greater_or_equal_to:edge ->
                              ?less_or_equal_to:edge ->
                              t -> edge Base__.Sequence.t
                            val merge_to_sequence :
                              ?order:[ `Decreasing | `Increasing ] ->
                              ?greater_or_equal_to:edge ->
                              ?less_or_equal_to:edge ->
                              t ->
                              t ->
                              (edge, edge)
                              Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                              Base__.Sequence.t
                            val to_map :
                              t ->
                              f:(edge -> 'data) ->
                              (edge, 'data, comparator_witness)
                              Core_kernel__.Core_set_intf.Map.t
                            val obs :
                              edge Core_kernel__.Quickcheck.Observer.t ->
                              t Core_kernel__.Quickcheck.Observer.t
                            val shrinker :
                              edge Core_kernel__.Quickcheck.Shrinker.t ->
                              t Core_kernel__.Quickcheck.Shrinker.t
                            val empty : t
                            val singleton : edge -> t
                            val union_list : t list -> t
                            val of_list : edge list -> t
                            val of_array : edge array -> t
                            val of_sorted_array :
                              edge array -> t Base__.Or_error.t
                            val of_sorted_array_unchecked : edge array -> t
                            val of_increasing_iterator_unchecked :
                              len:int -> f:(int -> edge) -> t
                            val stable_dedup_list : edge list -> edge list
                            val map :
                              ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                              f:('-> edge) -> t
                            val filter_map :
                              ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                              f:('-> edge option) -> t
                            val of_tree : t -> t
                            val of_hash_set :
                              edge Core_kernel__.Hash_set.t -> t
                            val of_hashtbl_keys :
                              (edge, 'a) Core_kernel__.Core_hashtbl.t -> t
                            val of_map_keys :
                              (edge, 'a, comparator_witness)
                              Core_kernel__.Core_set_intf.Map.t -> t
                            val gen :
                              edge Core_kernel__.Quickcheck.Generator.t ->
                              t Core_kernel__.Quickcheck.Generator.t
                            module Provide_of_sexp :
                              functor
                                (Elt : sig
                                         val t_of_sexp :
                                           Sexplib.Sexp.t -> edge
                                       end->
                                sig val t_of_sexp : Sexplib.Sexp.t -> t end
                            val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                            val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                          end
                        type t = (edge, comparator_witness) Base.Set.t
                        val compare : t -> t -> Core_kernel__.Import.int
                        val length : t -> int
                        val is_empty : t -> bool
                        val iter : t -> f:(edge -> unit) -> unit
                        val fold :
                          t ->
                          init:'accum ->
                          f:('accum -> edge -> 'accum) -> 'accum
                        val fold_result :
                          t ->
                          init:'accum ->
                          f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
                          ('accum, 'e) Base__.Result.t
                        val exists : t -> f:(edge -> bool) -> bool
                        val for_all : t -> f:(edge -> bool) -> bool
                        val count : t -> f:(edge -> bool) -> int
                        val sum :
                          (module Base__.Commutative_group.S with type t = 'sum) ->
                          t -> f:(edge -> 'sum) -> 'sum
                        val find : t -> f:(edge -> bool) -> edge option
                        val find_map :
                          t -> f:(edge -> 'a option) -> 'a option
                        val to_list : t -> edge list
                        val to_array : t -> edge array
                        val invariants : t -> bool
                        val mem : t -> edge -> bool
                        val add : t -> edge -> t
                        val remove : t -> edge -> t
                        val union : t -> t -> t
                        val inter : t -> t -> t
                        val diff : t -> t -> t
                        val symmetric_diff :
                          t ->
                          t -> (edge, edge) Base__.Either.t Base__.Sequence.t
                        val compare_direct : t -> t -> int
                        val equal : t -> t -> bool
                        val is_subset : t -> of_:t -> bool
                        val subset : t -> t -> bool
                        val fold_until :
                          t ->
                          init:'->
                          f:('->
                             edge ->
                             ('b, 'stop)
                             Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                          ('b, 'stop)
                          Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                        val fold_right :
                          t -> init:'-> f:(edge -> '-> 'b) -> 'b
                        val iter2 :
                          t ->
                          t ->
                          f:([ `Both of edge * edge
                             | `Left of edge
                             | `Right of edge ] -> unit) ->
                          unit
                        val filter : t -> f:(edge -> bool) -> t
                        val partition_tf : t -> f:(edge -> bool) -> t * t
                        val elements : t -> edge list
                        val min_elt : t -> edge option
                        val min_elt_exn : t -> edge
                        val max_elt : t -> edge option
                        val max_elt_exn : t -> edge
                        val choose : t -> edge option
                        val choose_exn : t -> edge
                        val split : t -> edge -> t * edge option * t
                        val group_by :
                          t -> equiv:(edge -> edge -> bool) -> t list
                        val find_exn : t -> f:(edge -> bool) -> edge
                        val find_index : t -> int -> edge option
                        val nth : t -> int -> edge option
                        val remove_index : t -> int -> t
                        val to_tree : t -> Tree.t
                        val to_sequence :
                          ?order:[ `Decreasing | `Increasing ] ->
                          ?greater_or_equal_to:edge ->
                          ?less_or_equal_to:edge ->
                          t -> edge Base__.Sequence.t
                        val merge_to_sequence :
                          ?order:[ `Decreasing | `Increasing ] ->
                          ?greater_or_equal_to:edge ->
                          ?less_or_equal_to:edge ->
                          t ->
                          t ->
                          (edge, edge)
                          Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                          Base__.Sequence.t
                        val to_map :
                          t ->
                          f:(edge -> 'data) ->
                          (edge, 'data, comparator_witness)
                          Core_kernel__.Core_set_intf.Map.t
                        val obs :
                          edge Core_kernel__.Quickcheck.Observer.t ->
                          t Core_kernel__.Quickcheck.Observer.t
                        val shrinker :
                          edge Core_kernel__.Quickcheck.Shrinker.t ->
                          t Core_kernel__.Quickcheck.Shrinker.t
                        val empty : t
                        val singleton : edge -> t
                        val union_list : t list -> t
                        val of_list : edge list -> t
                        val of_array : edge array -> t
                        val of_sorted_array :
                          edge array -> t Base__.Or_error.t
                        val of_sorted_array_unchecked : edge array -> t
                        val of_increasing_iterator_unchecked :
                          len:int -> f:(int -> edge) -> t
                        val stable_dedup_list : edge list -> edge list
                        val map : ('a, 'b) Base.Set.t -> f:('-> edge) -> t
                        val filter_map :
                          ('a, 'b) Base.Set.t -> f:('-> edge option) -> t
                        val of_tree : Tree.t -> t
                        val of_hash_set : edge Core_kernel__.Hash_set.t -> t
                        val of_hashtbl_keys :
                          (edge, 'a) Core_kernel__.Core_hashtbl.t -> t
                        val of_map_keys :
                          (edge, 'a, comparator_witness)
                          Core_kernel__.Core_set_intf.Map.t -> t
                        val gen :
                          edge Core_kernel__.Quickcheck.Generator.t ->
                          t Core_kernel__.Quickcheck.Generator.t
                        module Provide_of_sexp :
                          functor
                            (Elt : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> edge
                                   end->
                            sig val t_of_sexp : Sexplib.Sexp.t -> t end
                        module Provide_bin_io :
                          functor
                            (Elt : sig
                                     val bin_t : edge Bin_prot.Type_class.t
                                     val bin_read_t :
                                       edge Bin_prot.Read.reader
                                     val __bin_read_t__ :
                                       (Core_kernel__.Import.int -> edge)
                                       Bin_prot.Read.reader
                                     val bin_reader_t :
                                       edge Bin_prot.Type_class.reader
                                     val bin_size_t :
                                       edge Bin_prot.Size.sizer
                                     val bin_write_t :
                                       edge Bin_prot.Write.writer
                                     val bin_writer_t :
                                       edge Bin_prot.Type_class.writer
                                     val bin_shape_t : Bin_prot.Shape.t
                                   end->
                            sig
                              val bin_size_t : t Bin_prot.Size.sizer
                              val bin_write_t : t Bin_prot.Write.writer
                              val bin_read_t : t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                (int -> t) Bin_prot.Read.reader
                              val bin_shape_t : Bin_prot.Shape.t
                              val bin_writer_t : t Bin_prot.Type_class.writer
                              val bin_reader_t : t Bin_prot.Type_class.reader
                              val bin_t : t Bin_prot.Type_class.t
                            end
                        module Provide_hash :
                          functor
                            (Elt : sig
                                     val hash_fold_t :
                                       Base__.Hash.state ->
                                       edge -> Base__.Hash.state
                                   end->
                            sig
                              val hash_fold_t :
                                Ppx_hash_lib.Std.Hash.state ->
                                t -> Ppx_hash_lib.Std.Hash.state
                              val hash :
                                t -> Ppx_hash_lib.Std.Hash.hash_value
                            end
                        val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                        val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                      end
                    val hash : t -> Core_kernel__.Import.int
                    val compare : t -> t -> Core_kernel__.Import.int
                    val hashable :
                      t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
                    module Table :
                      sig
                        type key = t
                        type ('a, 'b) hashtbl = ('a, 'b) Node.Table.hashtbl
                        type 'b t = (key, 'b) hashtbl
                        val sexp_of_t :
                          ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                        type ('a, 'b) t_ = 'b t
                        type 'a key_ = key
                        val hashable :
                          key Core_kernel__.Core_hashtbl_intf.Hashable.t
                        val invariant :
                          'Base__.Invariant_intf.inv ->
                          'a t Base__.Invariant_intf.inv
                        val create :
                          (key, 'b, unit -> 'b t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist :
                          (key, 'b,
                           (key * 'b) list ->
                           [ `Duplicate_key of key | `Ok of 'b t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_report_all_dups :
                          (key, 'b,
                           (key * 'b) list ->
                           [ `Duplicate_keys of key list | `Ok of 'b t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_or_error :
                          (key, 'b,
                           (key * 'b) list -> 'b t Base__.Or_error.t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_exn :
                          (key, 'b, (key * 'b) list -> 'b t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_multi :
                          (key, 'b list, (key * 'b) list -> 'b list t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_mapped :
                          (key, 'b,
                           get_key:('-> key) ->
                           get_data:('-> 'b) ->
                           'r list ->
                           [ `Duplicate_keys of key list | `Ok of 'b t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_with_key :
                          (key, 'r,
                           get_key:('-> key) ->
                           'r list ->
                           [ `Duplicate_keys of key list | `Ok of 'r t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_with_key_or_error :
                          (key, 'r,
                           get_key:('-> key) ->
                           'r list -> 'r t Base__.Or_error.t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_with_key_exn :
                          (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val group :
                          (key, 'b,
                           get_key:('-> key) ->
                           get_data:('-> 'b) ->
                           combine:('-> '-> 'b) -> 'r list -> 'b t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                        val clear : 'a t -> unit
                        val copy : 'b t -> 'b t
                        val fold :
                          'b t ->
                          init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                        val iter_keys : 'a t -> f:(key -> unit) -> unit
                        val iter : 'b t -> f:('-> unit) -> unit
                        val iteri :
                          'b t -> f:(key:key -> data:'-> unit) -> unit
                        val iter_vals : 'b t -> f:('-> unit) -> unit
                        val existsi :
                          'b t -> f:(key:key -> data:'-> bool) -> bool
                        val exists : 'b t -> f:('-> bool) -> bool
                        val for_alli :
                          'b t -> f:(key:key -> data:'-> bool) -> bool
                        val for_all : 'b t -> f:('-> bool) -> bool
                        val counti :
                          'b t -> f:(key:key -> data:'-> bool) -> int
                        val count : 'b t -> f:('-> bool) -> int
                        val length : 'a t -> int
                        val is_empty : 'a t -> bool
                        val mem : 'a t -> key -> bool
                        val remove : 'a t -> key -> unit
                        val replace : 'b t -> key:key -> data:'-> unit
                        val set : 'b t -> key:key -> data:'-> unit
                        val add :
                          'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                        val add_or_error :
                          'b t ->
                          key:key -> data:'-> unit Base__.Or_error.t
                        val add_exn : 'b t -> key:key -> data:'-> unit
                        val change :
                          'b t -> key -> f:('b option -> 'b option) -> unit
                        val update :
                          'b t -> key -> f:('b option -> 'b) -> unit
                        val add_multi :
                          'b list t -> key:key -> data:'-> unit
                        val remove_multi : 'a list t -> key -> unit
                        val map : 'b t -> f:('-> 'c) -> 'c t
                        val mapi :
                          'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                        val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                        val filter_mapi :
                          'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                        val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                        val filter : 'b t -> f:('-> bool) -> 'b t
                        val filteri :
                          'b t -> f:(key:key -> data:'-> bool) -> 'b t
                        val partition_map :
                          'b t ->
                          f:('-> [ `Fst of '| `Snd of 'd ]) ->
                          'c t * 'd t
                        val partition_mapi :
                          'b t ->
                          f:(key:key ->
                             data:'-> [ `Fst of '| `Snd of 'd ]) ->
                          'c t * 'd t
                        val partition_tf :
                          'b t -> f:('-> bool) -> 'b t * 'b t
                        val partitioni_tf :
                          'b t ->
                          f:(key:key -> data:'-> bool) -> 'b t * 'b t
                        val find_or_add :
                          'b t -> key -> default:(unit -> 'b) -> 'b
                        val find : 'b t -> key -> 'b option
                        val find_exn : 'b t -> key -> 'b
                        val find_and_call :
                          'b t ->
                          key ->
                          if_found:('-> 'c) ->
                          if_not_found:(key -> 'c) -> 'c
                        val find_and_remove : 'b t -> key -> 'b option
                        val merge :
                          'a t ->
                          'b t ->
                          f:(key:key ->
                             [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                             'c option) ->
                          'c t
                        type 'a merge_into_action = Remove | Set_to of 'a
                        val merge_into :
                          src:'a t ->
                          dst:'b t ->
                          f:(key:key ->
                             '-> 'b option -> 'b merge_into_action) ->
                          unit
                        val keys : 'a t -> key list
                        val data : 'b t -> 'b list
                        val filter_keys_inplace :
                          'a t -> f:(key -> bool) -> unit
                        val filter_inplace : 'b t -> f:('-> bool) -> unit
                        val filteri_inplace :
                          'b t -> f:(key:key -> data:'-> bool) -> unit
                        val map_inplace : 'b t -> f:('-> 'b) -> unit
                        val mapi_inplace :
                          'b t -> f:(key:key -> data:'-> 'b) -> unit
                        val filter_map_inplace :
                          'b t -> f:('-> 'b option) -> unit
                        val filter_mapi_inplace :
                          'b t -> f:(key:key -> data:'-> 'b option) -> unit
                        val replace_all : 'b t -> f:('-> 'b) -> unit
                        val replace_alli :
                          'b t -> f:(key:key -> data:'-> 'b) -> unit
                        val filter_replace_all :
                          'b t -> f:('-> 'b option) -> unit
                        val filter_replace_alli :
                          'b t -> f:(key:key -> data:'-> 'b option) -> unit
                        val equal :
                          'b t -> 'b t -> ('-> '-> bool) -> bool
                        val similar :
                          'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                        val to_alist : 'b t -> (key * 'b) list
                        val validate :
                          name:(key -> string) ->
                          'Base__.Validate.check ->
                          'b t Base__.Validate.check
                        val incr :
                          ?by:int ->
                          ?remove_if_zero:bool -> int t -> key -> unit
                        val decr :
                          ?by:int ->
                          ?remove_if_zero:bool -> int t -> key -> unit
                        module Provide_of_sexp :
                          functor
                            (Key : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> key
                                   end->
                            sig
                              val t_of_sexp :
                                (Sexplib.Sexp.t -> 'v_x__001_) ->
                                Sexplib.Sexp.t -> 'v_x__001_ t
                            end
                        module Provide_bin_io :
                          functor
                            (Key : sig
                                     val bin_t : key Bin_prot.Type_class.t
                                     val bin_read_t :
                                       key Bin_prot.Read.reader
                                     val __bin_read_t__ :
                                       (Core_kernel__.Import.int -> key)
                                       Bin_prot.Read.reader
                                     val bin_reader_t :
                                       key Bin_prot.Type_class.reader
                                     val bin_size_t : key Bin_prot.Size.sizer
                                     val bin_write_t :
                                       key Bin_prot.Write.writer
                                     val bin_writer_t :
                                       key Bin_prot.Type_class.writer
                                     val bin_shape_t : Bin_prot.Shape.t
                                   end->
                            sig
                              val bin_t :
                                'Bin_prot.Type_class.t ->
                                'a t Bin_prot.Type_class.t
                              val bin_read_t :
                                'Bin_prot.Read.reader ->
                                'a t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                'Bin_prot.Read.reader ->
                                (Core_kernel__.Import.int -> 'a t)
                                Bin_prot.Read.reader
                              val bin_reader_t :
                                'Bin_prot.Type_class.reader ->
                                'a t Bin_prot.Type_class.reader
                              val bin_size_t :
                                'Bin_prot.Size.sizer ->
                                'a t Bin_prot.Size.sizer
                              val bin_write_t :
                                'Bin_prot.Write.writer ->
                                'a t Bin_prot.Write.writer
                              val bin_writer_t :
                                'Bin_prot.Type_class.writer ->
                                'a t Bin_prot.Type_class.writer
                              val bin_shape_t :
                                Bin_prot.Shape.t -> Bin_prot.Shape.t
                            end
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__002_) ->
                          Sexplib.Sexp.t -> 'v_x__002_ t
                      end
                    module Hash_set :
                      sig
                        type elt = t
                        type t = elt Core_kernel__.Hash_set.t
                        val sexp_of_t : t -> Sexplib.Sexp.t
                        type 'a t_ = t
                        type 'a elt_ = elt
                        val create :
                          ('a, unit -> t)
                          Core_kernel__.Hash_set_intf.create_options_without_hashable
                        val of_list :
                          ('a, elt list -> t)
                          Core_kernel__.Hash_set_intf.create_options_without_hashable
                        module Provide_of_sexp :
                          functor
                            (X : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> elt
                                 end->
                            sig val t_of_sexp : Sexplib.Sexp.t -> t end
                        module Provide_bin_io :
                          functor
                            (X : sig
                                   val bin_t : elt Bin_prot.Type_class.t
                                   val bin_read_t : elt Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> elt)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     elt Bin_prot.Type_class.reader
                                   val bin_size_t : elt Bin_prot.Size.sizer
                                   val bin_write_t :
                                     elt Bin_prot.Write.writer
                                   val bin_writer_t :
                                     elt Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                            sig
                              val bin_t : t Bin_prot.Type_class.t
                              val bin_read_t : t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                (Core_kernel__.Import.int -> t)
                                Bin_prot.Read.reader
                              val bin_reader_t : t Bin_prot.Type_class.reader
                              val bin_size_t : t Bin_prot.Size.sizer
                              val bin_write_t : t Bin_prot.Write.writer
                              val bin_writer_t : t Bin_prot.Type_class.writer
                              val bin_shape_t : Bin_prot.Shape.t
                            end
                        val t_of_sexp : Sexplib.Sexp.t -> t
                      end
                    module Hash_queue :
                      sig
                        module Key :
                          sig
                            type t = edge
                            val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                            val compare : t -> t -> int
                            val hash : t -> int
                          end
                        type 'a t
                        val sexp_of_t :
                          ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                        val length : 'a t -> int
                        val is_empty : 'a t -> bool
                        val iter : 'a t -> f:('-> unit) -> unit
                        val fold :
                          'a t ->
                          init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                        val fold_result :
                          'a t ->
                          init:'accum ->
                          f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                          ('accum, 'e) Base__.Result.t
                        val fold_until :
                          'a t ->
                          init:'accum ->
                          f:('accum ->
                             '->
                             ('accum, 'stop)
                             Base.Container_intf.Continue_or_stop.t) ->
                          ('accum, 'stop)
                          Base.Container_intf.Finished_or_stopped_early.t
                        val exists : 'a t -> f:('-> bool) -> bool
                        val for_all : 'a t -> f:('-> bool) -> bool
                        val count : 'a t -> f:('-> bool) -> int
                        val sum :
                          (module Base__.Commutative_group.S with type t = 'sum) ->
                          'a t -> f:('-> 'sum) -> 'sum
                        val find : 'a t -> f:('-> bool) -> 'a option
                        val find_map :
                          'a t -> f:('-> 'b option) -> 'b option
                        val to_list : 'a t -> 'a list
                        val to_array : 'a t -> 'a array
                        val min_elt :
                          'a t -> cmp:('-> '-> int) -> 'a option
                        val max_elt :
                          'a t -> cmp:('-> '-> int) -> 'a option
                        val invariant : 'a t -> Core_kernel__.Import.unit
                        val create :
                          ?growth_allowed:Core_kernel__.Import.bool ->
                          ?size:Core_kernel__.Import.int ->
                          Core_kernel__.Import.unit -> 'a t
                        val clear : 'a t -> Core_kernel__.Import.unit
                        val mem : 'a t -> edge -> Core_kernel__.Import.bool
                        val lookup :
                          'a t -> edge -> 'Core_kernel__.Import.option
                        val lookup_exn : 'a t -> edge -> 'a
                        val enqueue :
                          'a t ->
                          edge -> '-> [ `Key_already_present | `Ok ]
                        val enqueue_exn :
                          'a t -> edge -> '-> Core_kernel__.Import.unit
                        val lookup_and_move_to_back :
                          'a t -> edge -> 'Core_kernel__.Import.option
                        val lookup_and_move_to_back_exn : 'a t -> edge -> 'a
                        val first : 'a t -> 'Core_kernel__.Import.option
                        val first_with_key :
                          'a t -> (edge * 'a) Core_kernel__.Import.option
                        val keys : 'a t -> edge Core_kernel__.Import.list
                        val dequeue : 'a t -> 'Core_kernel__.Import.option
                        val dequeue_exn : 'a t -> 'a
                        val dequeue_with_key :
                          'a t -> (edge * 'a) Core_kernel__.Import.option
                        val dequeue_with_key_exn : 'a t -> edge * 'a
                        val dequeue_all :
                          'a t ->
                          f:('-> Core_kernel__.Import.unit) ->
                          Core_kernel__.Import.unit
                        val remove : 'a t -> edge -> [ `No_such_key | `Ok ]
                        val remove_exn :
                          'a t -> edge -> Core_kernel__.Import.unit
                        val replace :
                          'a t -> edge -> '-> [ `No_such_key | `Ok ]
                        val replace_exn :
                          'a t -> edge -> '-> Core_kernel__.Import.unit
                        val iteri :
                          'a t ->
                          f:(key:edge -> data:'-> Core_kernel__.Import.unit) ->
                          Core_kernel__.Import.unit
                        val foldi :
                          'a t ->
                          init:'->
                          f:('-> key:edge -> data:'-> 'b) -> 'b
                      end
                  end
                val empty : t
                val nodes : t -> node Regular.Std.seq
                val edges : t -> edge Regular.Std.seq
                val is_directed : bool
                val number_of_edges : t -> int
                val number_of_nodes : t -> int
                val ( >= ) : t -> t -> bool
                val ( <= ) : t -> t -> bool
                val ( = ) : t -> t -> bool
                val ( > ) : t -> t -> bool
                val ( < ) : t -> t -> bool
                val ( <> ) : t -> t -> bool
                val equal : t -> t -> bool
                val min : t -> t -> t
                val max : t -> t -> t
                val ascending : t -> t -> int
                val descending : t -> t -> int
                val between : t -> low:t -> high:t -> bool
                val clamp_exn : t -> min:t -> max:t -> t
                val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
                type comparator_witness
                val comparator :
                  (t, comparator_witness) Base__.Comparator.comparator
                val validate_lbound :
                  min:t Base__.Maybe_bound.t -> t Base__.Validate.check
                val validate_ubound :
                  max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                val validate_bound :
                  min:t Base__.Maybe_bound.t ->
                  max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                module Replace_polymorphic_compare :
                  sig
                    val ( >= ) : t -> t -> bool
                    val ( <= ) : t -> t -> bool
                    val ( = ) : t -> t -> bool
                    val ( > ) : t -> t -> bool
                    val ( < ) : t -> t -> bool
                    val ( <> ) : t -> t -> bool
                    val equal : t -> t -> bool
                    val compare : t -> t -> int
                    val min : t -> t -> t
                    val max : t -> t -> t
                  end
                module Map :
                  sig
                    module Key :
                      sig
                        type t = Edge.graph
                        val t_of_sexp : Sexplib.Sexp.t -> t
                        val sexp_of_t : t -> Sexplib.Sexp.t
                        type comparator_witness = comparator_witness
                        val comparator :
                          (t, comparator_witness)
                          Core_kernel__.Comparator.comparator
                      end
                    module Tree :
                      sig
                        type 'a t =
                            (Key.t, 'a, comparator_witness)
                            Core_kernel__.Core_map_intf.Tree.t
                        val empty : 'a t
                        val singleton : Key.t -> '-> 'a t
                        val of_alist :
                          (Key.t * 'a) list ->
                          [ `Duplicate_key of Key.t | `Ok of 'a t ]
                        val of_alist_or_error :
                          (Key.t * 'a) list -> 'a t Base__.Or_error.t
                        val of_alist_exn : (Key.t * 'a) list -> 'a t
                        val of_alist_multi : (Key.t * 'a) list -> 'a list t
                        val of_alist_fold :
                          (Key.t * 'a) list ->
                          init:'-> f:('-> '-> 'b) -> 'b t
                        val of_alist_reduce :
                          (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                        val of_sorted_array :
                          (Key.t * 'a) array -> 'a t Base__.Or_error.t
                        val of_sorted_array_unchecked :
                          (Key.t * 'a) array -> 'a t
                        val of_increasing_iterator_unchecked :
                          len:int -> f:(int -> Key.t * 'a) -> 'a t
                        val of_iteri :
                          iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                          [ `Duplicate_key of Key.t | `Ok of 'v t ]
                        val of_tree : 'a t -> 'a t
                        val of_hashtbl_exn :
                          (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                        val gen :
                          Key.t Core_kernel__.Quickcheck.Generator.t ->
                          'Core_kernel__.Quickcheck.Generator.t ->
                          'a t Core_kernel__.Quickcheck.Generator.t
                        val invariants : 'a t -> bool
                        val is_empty : 'a t -> bool
                        val length : 'a t -> int
                        val add : 'a t -> key:Key.t -> data:'-> 'a t
                        val add_multi :
                          'a list t -> key:Key.t -> data:'-> 'a list t
                        val remove_multi : 'a list t -> Key.t -> 'a list t
                        val change :
                          'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                        val update :
                          'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                        val find : 'a t -> Key.t -> 'a option
                        val find_exn : 'a t -> Key.t -> 'a
                        val remove : 'a t -> Key.t -> 'a t
                        val mem : 'a t -> Key.t -> bool
                        val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                        val iter : 'a t -> f:('-> unit) -> unit
                        val iteri :
                          'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                        val iter2 :
                          'a t ->
                          'b t ->
                          f:(key:Key.t ->
                             data:[ `Both of 'a * 'b
                                  | `Left of 'a
                                  | `Right of 'b ] ->
                             unit) ->
                          unit
                        val map : 'a t -> f:('-> 'b) -> 'b t
                        val mapi :
                          'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                        val fold :
                          'a t ->
                          init:'->
                          f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                        val fold_right :
                          'a t ->
                          init:'->
                          f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                        val fold2 :
                          'a t ->
                          'b t ->
                          init:'->
                          f:(key:Key.t ->
                             data:[ `Both of 'a * 'b
                                  | `Left of 'a
                                  | `Right of 'b ] ->
                             '-> 'c) ->
                          'c
                        val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                        val filter : 'a t -> f:('-> bool) -> 'a t
                        val filteri :
                          'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                        val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                        val filter_mapi :
                          'a t ->
                          f:(key:Key.t -> data:'-> 'b option) -> 'b t
                        val partition_mapi :
                          'a t ->
                          f:(key:Key.t ->
                             data:'-> [ `Fst of '| `Snd of 'c ]) ->
                          'b t * 'c t
                        val partition_map :
                          'a t ->
                          f:('-> [ `Fst of '| `Snd of 'c ]) ->
                          'b t * 'c t
                        val partitioni_tf :
                          'a t ->
                          f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                        val partition_tf :
                          'a t -> f:('-> bool) -> 'a t * 'a t
                        val compare_direct :
                          ('-> '-> int) -> 'a t -> 'a t -> int
                        val equal :
                          ('-> '-> bool) -> 'a t -> 'a t -> bool
                        val keys : 'a t -> Key.t list
                        val data : 'a t -> 'a list
                        val to_alist :
                          ?key_order:[ `Decreasing | `Increasing ] ->
                          'a t -> (Key.t * 'a) list
                        val validate :
                          name:(Key.t -> string) ->
                          'Base__.Validate.check ->
                          'a t Base__.Validate.check
                        val merge :
                          'a t ->
                          'b t ->
                          f:(key:Key.t ->
                             [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                             'c option) ->
                          'c t
                        val symmetric_diff :
                          'a t ->
                          'a t ->
                          data_equal:('-> '-> bool) ->
                          (Key.t, 'a)
                          Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                          Base__.Sequence.t
                        val min_elt : 'a t -> (Key.t * 'a) option
                        val min_elt_exn : 'a t -> Key.t * 'a
                        val max_elt : 'a t -> (Key.t * 'a) option
                        val max_elt_exn : 'a t -> Key.t * 'a
                        val for_all : 'a t -> f:('-> bool) -> bool
                        val for_alli :
                          'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                        val exists : 'a t -> f:('-> bool) -> bool
                        val existsi :
                          'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                        val count : 'a t -> f:('-> bool) -> int
                        val counti :
                          'a t -> f:(key:Key.t -> data:'-> bool) -> int
                        val split :
                          'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                        val append :
                          lower_part:'a t ->
                          upper_part:'a t ->
                          [ `Ok of 'a t | `Overlapping_key_ranges ]
                        val subrange :
                          'a t ->
                          lower_bound:Key.t Base__.Maybe_bound.t ->
                          upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                        val fold_range_inclusive :
                          'a t ->
                          min:Key.t ->
                          max:Key.t ->
                          init:'->
                          f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                        val range_to_alist :
                          'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                        val closest_key :
                          'a t ->
                          [ `Greater_or_equal_to
                          | `Greater_than
                          | `Less_or_equal_to
                          | `Less_than ] -> Key.t -> (Key.t * 'a) option
                        val nth : 'a t -> int -> (Key.t * 'a) option
                        val nth_exn : 'a t -> int -> Key.t * 'a
                        val rank : 'a t -> Key.t -> int option
                        val to_tree : 'a t -> 'a t
                        val to_sequence :
                          ?order:[ `Decreasing_key | `Increasing_key ] ->
                          ?keys_greater_or_equal_to:Key.t ->
                          ?keys_less_or_equal_to:Key.t ->
                          'a t -> (Key.t * 'a) Base__.Sequence.t
                        val obs :
                          Key.t Core_kernel__.Quickcheck.Observer.t ->
                          'Core_kernel__.Quickcheck.Observer.t ->
                          'v t Core_kernel__.Quickcheck.Observer.t
                        val shrinker :
                          Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                          'Core_kernel__.Quickcheck.Shrinker.t ->
                          'v t Core_kernel__.Quickcheck.Shrinker.t
                        module Provide_of_sexp :
                          functor
                            (K : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> Key.t
                                 end->
                            sig
                              val t_of_sexp :
                                (Sexplib.Sexp.t -> 'v_x__017_) ->
                                Sexplib.Sexp.t -> 'v_x__017_ t
                            end
                        val t_of_sexp :
                          (Base__.Sexplib.Sexp.t -> 'a) ->
                          Base__.Sexplib.Sexp.t -> 'a t
                        val sexp_of_t :
                          ('-> Base__.Sexplib.Sexp.t) ->
                          'a t -> Base__.Sexplib.Sexp.t
                      end
                    type 'a t =
                        (Key.t, 'a, comparator_witness)
                        Core_kernel__.Core_map_intf.Map.t
                    val compare :
                      ('-> '-> Core_kernel__.Import.int) ->
                      'a t -> 'a t -> Core_kernel__.Import.int
                    val empty : 'a t
                    val singleton : Key.t -> '-> 'a t
                    val of_alist :
                      (Key.t * 'a) list ->
                      [ `Duplicate_key of Key.t | `Ok of 'a t ]
                    val of_alist_or_error :
                      (Key.t * 'a) list -> 'a t Base__.Or_error.t
                    val of_alist_exn : (Key.t * 'a) list -> 'a t
                    val of_alist_multi : (Key.t * 'a) list -> 'a list t
                    val of_alist_fold :
                      (Key.t * 'a) list ->
                      init:'-> f:('-> '-> 'b) -> 'b t
                    val of_alist_reduce :
                      (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                    val of_sorted_array :
                      (Key.t * 'a) array -> 'a t Base__.Or_error.t
                    val of_sorted_array_unchecked :
                      (Key.t * 'a) array -> 'a t
                    val of_increasing_iterator_unchecked :
                      len:int -> f:(int -> Key.t * 'a) -> 'a t
                    val of_iteri :
                      iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                      [ `Duplicate_key of Key.t | `Ok of 'v t ]
                    val of_tree : 'Tree.t -> 'a t
                    val of_hashtbl_exn :
                      (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                    val gen :
                      Key.t Core_kernel__.Quickcheck.Generator.t ->
                      'Core_kernel__.Quickcheck.Generator.t ->
                      'a t Core_kernel__.Quickcheck.Generator.t
                    val invariants : 'a t -> bool
                    val is_empty : 'a t -> bool
                    val length : 'a t -> int
                    val add : 'a t -> key:Key.t -> data:'-> 'a t
                    val add_multi :
                      'a list t -> key:Key.t -> data:'-> 'a list t
                    val remove_multi : 'a list t -> Key.t -> 'a list t
                    val change :
                      'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                    val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                    val find : 'a t -> Key.t -> 'a option
                    val find_exn : 'a t -> Key.t -> 'a
                    val remove : 'a t -> Key.t -> 'a t
                    val mem : 'a t -> Key.t -> bool
                    val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                    val iter : 'a t -> f:('-> unit) -> unit
                    val iteri :
                      'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                    val iter2 :
                      'a t ->
                      'b t ->
                      f:(key:Key.t ->
                         data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                         unit) ->
                      unit
                    val map : 'a t -> f:('-> 'b) -> 'b t
                    val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                    val fold :
                      'a t ->
                      init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                    val fold_right :
                      'a t ->
                      init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                    val fold2 :
                      'a t ->
                      'b t ->
                      init:'->
                      f:(key:Key.t ->
                         data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                         '-> 'c) ->
                      'c
                    val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                    val filter : 'a t -> f:('-> bool) -> 'a t
                    val filteri :
                      'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                    val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                    val filter_mapi :
                      'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                    val partition_mapi :
                      'a t ->
                      f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                      'b t * 'c t
                    val partition_map :
                      'a t ->
                      f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                    val partitioni_tf :
                      'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                    val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                    val compare_direct :
                      ('-> '-> int) -> 'a t -> 'a t -> int
                    val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                    val keys : 'a t -> Key.t list
                    val data : 'a t -> 'a list
                    val to_alist :
                      ?key_order:[ `Decreasing | `Increasing ] ->
                      'a t -> (Key.t * 'a) list
                    val validate :
                      name:(Key.t -> string) ->
                      'Base__.Validate.check -> 'a t Base__.Validate.check
                    val merge :
                      'a t ->
                      'b t ->
                      f:(key:Key.t ->
                         [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                         'c option) ->
                      'c t
                    val symmetric_diff :
                      'a t ->
                      'a t ->
                      data_equal:('-> '-> bool) ->
                      (Key.t, 'a)
                      Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                      Base__.Sequence.t
                    val min_elt : 'a t -> (Key.t * 'a) option
                    val min_elt_exn : 'a t -> Key.t * 'a
                    val max_elt : 'a t -> (Key.t * 'a) option
                    val max_elt_exn : 'a t -> Key.t * 'a
                    val for_all : 'a t -> f:('-> bool) -> bool
                    val for_alli :
                      'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                    val exists : 'a t -> f:('-> bool) -> bool
                    val existsi :
                      'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                    val count : 'a t -> f:('-> bool) -> int
                    val counti :
                      'a t -> f:(key:Key.t -> data:'-> bool) -> int
                    val split :
                      'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                    val append :
                      lower_part:'a t ->
                      upper_part:'a t ->
                      [ `Ok of 'a t | `Overlapping_key_ranges ]
                    val subrange :
                      'a t ->
                      lower_bound:Key.t Base__.Maybe_bound.t ->
                      upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                    val fold_range_inclusive :
                      'a t ->
                      min:Key.t ->
                      max:Key.t ->
                      init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                    val range_to_alist :
                      'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                    val closest_key :
                      'a t ->
                      [ `Greater_or_equal_to
                      | `Greater_than
                      | `Less_or_equal_to
                      | `Less_than ] -> Key.t -> (Key.t * 'a) option
                    val nth : 'a t -> int -> (Key.t * 'a) option
                    val nth_exn : 'a t -> int -> Key.t * 'a
                    val rank : 'a t -> Key.t -> int option
                    val to_tree : 'a t -> 'Tree.t
                    val to_sequence :
                      ?order:[ `Decreasing_key | `Increasing_key ] ->
                      ?keys_greater_or_equal_to:Key.t ->
                      ?keys_less_or_equal_to:Key.t ->
                      'a t -> (Key.t * 'a) Base__.Sequence.t
                    val obs :
                      Key.t Core_kernel__.Quickcheck.Observer.t ->
                      'Core_kernel__.Quickcheck.Observer.t ->
                      'v t Core_kernel__.Quickcheck.Observer.t
                    val shrinker :
                      Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                      'Core_kernel__.Quickcheck.Shrinker.t ->
                      'v t Core_kernel__.Quickcheck.Shrinker.t
                    module Provide_of_sexp :
                      functor
                        (Key : sig
                                 val t_of_sexp : Sexplib.Sexp.t -> Key.t
                               end->
                        sig
                          val t_of_sexp :
                            (Sexplib.Sexp.t -> 'v_x__018_) ->
                            Sexplib.Sexp.t -> 'v_x__018_ t
                        end
                    module Provide_bin_io :
                      functor
                        (Key : sig
                                 val bin_t : Key.t Bin_prot.Type_class.t
                                 val bin_read_t : Key.t Bin_prot.Read.reader
                                 val __bin_read_t__ :
                                   (Core_kernel__.Import.int -> Key.t)
                                   Bin_prot.Read.reader
                                 val bin_reader_t :
                                   Key.t Bin_prot.Type_class.reader
                                 val bin_size_t : Key.t Bin_prot.Size.sizer
                                 val bin_write_t :
                                   Key.t Bin_prot.Write.writer
                                 val bin_writer_t :
                                   Key.t Bin_prot.Type_class.writer
                                 val bin_shape_t : Bin_prot.Shape.t
                               end->
                        sig
                          val bin_shape_t :
                            Bin_prot.Shape.t -> Bin_prot.Shape.t
                          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                          val __bin_read_t__ :
                            ('a, int -> 'a t) Bin_prot.Read.reader1
                          val bin_writer_t :
                            ('a, 'a t) Bin_prot.Type_class.S1.writer
                          val bin_reader_t :
                            ('a, 'a t) Bin_prot.Type_class.S1.reader
                          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                        end
                    module Provide_hash :
                      functor
                        (Key : sig
                                 val hash_fold_t :
                                   Base__.Hash.state ->
                                   Key.t -> Base__.Hash.state
                               end->
                        sig
                          val hash_fold_t :
                            (Ppx_hash_lib.Std.Hash.state ->
                             '-> Ppx_hash_lib.Std.Hash.state) ->
                            Ppx_hash_lib.Std.Hash.state ->
                            'a t -> Ppx_hash_lib.Std.Hash.state
                        end
                    val t_of_sexp :
                      (Base__.Sexplib.Sexp.t -> 'a) ->
                      Base__.Sexplib.Sexp.t -> 'a t
                    val sexp_of_t :
                      ('-> Base__.Sexplib.Sexp.t) ->
                      'a t -> Base__.Sexplib.Sexp.t
                  end
                module Set :
                  sig
                    module Elt :
                      sig
                        type t = Edge.graph
                        val t_of_sexp : Sexplib.Sexp.t -> t
                        val sexp_of_t : t -> Sexplib.Sexp.t
                        type comparator_witness = Map.Key.comparator_witness
                        val comparator :
                          (t, comparator_witness)
                          Core_kernel__.Comparator.comparator
                      end
                    module Tree :
                      sig
                        type t =
                            (Elt.t, comparator_witness)
                            Core_kernel__.Core_set_intf.Tree.t
                        val compare : t -> t -> Core_kernel__.Import.int
                        val length : t -> int
                        val is_empty : t -> bool
                        val iter : t -> f:(Elt.t -> unit) -> unit
                        val fold :
                          t ->
                          init:'accum ->
                          f:('accum -> Elt.t -> 'accum) -> 'accum
                        val fold_result :
                          t ->
                          init:'accum ->
                          f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                          ('accum, 'e) Base__.Result.t
                        val exists : t -> f:(Elt.t -> bool) -> bool
                        val for_all : t -> f:(Elt.t -> bool) -> bool
                        val count : t -> f:(Elt.t -> bool) -> int
                        val sum :
                          (module Base__.Commutative_group.S with type t = 'sum) ->
                          t -> f:(Elt.t -> 'sum) -> 'sum
                        val find : t -> f:(Elt.t -> bool) -> Elt.t option
                        val find_map :
                          t -> f:(Elt.t -> 'a option) -> 'a option
                        val to_list : t -> Elt.t list
                        val to_array : t -> Elt.t array
                        val invariants : t -> bool
                        val mem : t -> Elt.t -> bool
                        val add : t -> Elt.t -> t
                        val remove : t -> Elt.t -> t
                        val union : t -> t -> t
                        val inter : t -> t -> t
                        val diff : t -> t -> t
                        val symmetric_diff :
                          t ->
                          t ->
                          (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                        val compare_direct : t -> t -> int
                        val equal : t -> t -> bool
                        val is_subset : t -> of_:t -> bool
                        val subset : t -> t -> bool
                        val fold_until :
                          t ->
                          init:'->
                          f:('->
                             Elt.t ->
                             ('b, 'stop)
                             Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                          ('b, 'stop)
                          Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                        val fold_right :
                          t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                        val iter2 :
                          t ->
                          t ->
                          f:([ `Both of Elt.t * Elt.t
                             | `Left of Elt.t
                             | `Right of Elt.t ] -> unit) ->
                          unit
                        val filter : t -> f:(Elt.t -> bool) -> t
                        val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                        val elements : t -> Elt.t list
                        val min_elt : t -> Elt.t option
                        val min_elt_exn : t -> Elt.t
                        val max_elt : t -> Elt.t option
                        val max_elt_exn : t -> Elt.t
                        val choose : t -> Elt.t option
                        val choose_exn : t -> Elt.t
                        val split : t -> Elt.t -> t * Elt.t option * t
                        val group_by :
                          t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                        val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                        val find_index : t -> int -> Elt.t option
                        val nth : t -> int -> Elt.t option
                        val remove_index : t -> int -> t
                        val to_tree : t -> t
                        val to_sequence :
                          ?order:[ `Decreasing | `Increasing ] ->
                          ?greater_or_equal_to:Elt.t ->
                          ?less_or_equal_to:Elt.t ->
                          t -> Elt.t Base__.Sequence.t
                        val merge_to_sequence :
                          ?order:[ `Decreasing | `Increasing ] ->
                          ?greater_or_equal_to:Elt.t ->
                          ?less_or_equal_to:Elt.t ->
                          t ->
                          t ->
                          (Elt.t, Elt.t)
                          Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                          Base__.Sequence.t
                        val to_map :
                          t ->
                          f:(Elt.t -> 'data) ->
                          (Elt.t, 'data, comparator_witness)
                          Core_kernel__.Core_set_intf.Map.t
                        val obs :
                          Elt.t Core_kernel__.Quickcheck.Observer.t ->
                          t Core_kernel__.Quickcheck.Observer.t
                        val shrinker :
                          Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                          t Core_kernel__.Quickcheck.Shrinker.t
                        val empty : t
                        val singleton : Elt.t -> t
                        val union_list : t list -> t
                        val of_list : Elt.t list -> t
                        val of_array : Elt.t array -> t
                        val of_sorted_array :
                          Elt.t array -> t Base__.Or_error.t
                        val of_sorted_array_unchecked : Elt.t array -> t
                        val of_increasing_iterator_unchecked :
                          len:int -> f:(int -> Elt.t) -> t
                        val stable_dedup_list : Elt.t list -> Elt.t list
                        val map :
                          ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                          f:('-> Elt.t) -> t
                        val filter_map :
                          ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                          f:('-> Elt.t option) -> t
                        val of_tree : t -> t
                        val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                        val of_hashtbl_keys :
                          (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                        val of_map_keys :
                          (Elt.t, 'a, comparator_witness)
                          Core_kernel__.Core_set_intf.Map.t -> t
                        val gen :
                          Elt.t Core_kernel__.Quickcheck.Generator.t ->
                          t Core_kernel__.Quickcheck.Generator.t
                        module Provide_of_sexp :
                          functor
                            (Elt : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> Elt.t
                                   end->
                            sig val t_of_sexp : Sexplib.Sexp.t -> t end
                        val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                        val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                      end
                    type t = (Elt.t, comparator_witness) Base.Set.t
                    val compare : t -> t -> Core_kernel__.Import.int
                    val length : t -> int
                    val is_empty : t -> bool
                    val iter : t -> f:(Elt.t -> unit) -> unit
                    val fold :
                      t ->
                      init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                    val fold_result :
                      t ->
                      init:'accum ->
                      f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                      ('accum, 'e) Base__.Result.t
                    val exists : t -> f:(Elt.t -> bool) -> bool
                    val for_all : t -> f:(Elt.t -> bool) -> bool
                    val count : t -> f:(Elt.t -> bool) -> int
                    val sum :
                      (module Base__.Commutative_group.S with type t = 'sum) ->
                      t -> f:(Elt.t -> 'sum) -> 'sum
                    val find : t -> f:(Elt.t -> bool) -> Elt.t option
                    val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                    val to_list : t -> Elt.t list
                    val to_array : t -> Elt.t array
                    val invariants : t -> bool
                    val mem : t -> Elt.t -> bool
                    val add : t -> Elt.t -> t
                    val remove : t -> Elt.t -> t
                    val union : t -> t -> t
                    val inter : t -> t -> t
                    val diff : t -> t -> t
                    val symmetric_diff :
                      t ->
                      t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                    val compare_direct : t -> t -> int
                    val equal : t -> t -> bool
                    val is_subset : t -> of_:t -> bool
                    val subset : t -> t -> bool
                    val fold_until :
                      t ->
                      init:'->
                      f:('->
                         Elt.t ->
                         ('b, 'stop)
                         Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                      ('b, 'stop)
                      Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                    val fold_right :
                      t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                    val iter2 :
                      t ->
                      t ->
                      f:([ `Both of Elt.t * Elt.t
                         | `Left of Elt.t
                         | `Right of Elt.t ] -> unit) ->
                      unit
                    val filter : t -> f:(Elt.t -> bool) -> t
                    val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                    val elements : t -> Elt.t list
                    val min_elt : t -> Elt.t option
                    val min_elt_exn : t -> Elt.t
                    val max_elt : t -> Elt.t option
                    val max_elt_exn : t -> Elt.t
                    val choose : t -> Elt.t option
                    val choose_exn : t -> Elt.t
                    val split : t -> Elt.t -> t * Elt.t option * t
                    val group_by :
                      t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                    val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                    val find_index : t -> int -> Elt.t option
                    val nth : t -> int -> Elt.t option
                    val remove_index : t -> int -> t
                    val to_tree : t -> Tree.t
                    val to_sequence :
                      ?order:[ `Decreasing | `Increasing ] ->
                      ?greater_or_equal_to:Elt.t ->
                      ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                    val merge_to_sequence :
                      ?order:[ `Decreasing | `Increasing ] ->
                      ?greater_or_equal_to:Elt.t ->
                      ?less_or_equal_to:Elt.t ->
                      t ->
                      t ->
                      (Elt.t, Elt.t)
                      Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                      Base__.Sequence.t
                    val to_map :
                      t ->
                      f:(Elt.t -> 'data) ->
                      (Elt.t, 'data, comparator_witness)
                      Core_kernel__.Core_set_intf.Map.t
                    val obs :
                      Elt.t Core_kernel__.Quickcheck.Observer.t ->
                      t Core_kernel__.Quickcheck.Observer.t
                    val shrinker :
                      Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                      t Core_kernel__.Quickcheck.Shrinker.t
                    val empty : t
                    val singleton : Elt.t -> t
                    val union_list : t list -> t
                    val of_list : Elt.t list -> t
                    val of_array : Elt.t array -> t
                    val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                    val of_sorted_array_unchecked : Elt.t array -> t
                    val of_increasing_iterator_unchecked :
                      len:int -> f:(int -> Elt.t) -> t
                    val stable_dedup_list : Elt.t list -> Elt.t list
                    val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
                    val filter_map :
                      ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
                    val of_tree : Tree.t -> t
                    val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                    val of_hashtbl_keys :
                      (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                    val of_map_keys :
                      (Elt.t, 'a, comparator_witness)
                      Core_kernel__.Core_set_intf.Map.t -> t
                    val gen :
                      Elt.t Core_kernel__.Quickcheck.Generator.t ->
                      t Core_kernel__.Quickcheck.Generator.t
                    module Provide_of_sexp :
                      functor
                        (Elt : sig
                                 val t_of_sexp : Sexplib.Sexp.t -> Elt.t
                               end->
                        sig val t_of_sexp : Sexplib.Sexp.t -> t end
                    module Provide_bin_io :
                      functor
                        (Elt : sig
                                 val bin_t : Elt.t Bin_prot.Type_class.t
                                 val bin_read_t : Elt.t Bin_prot.Read.reader
                                 val __bin_read_t__ :
                                   (Core_kernel__.Import.int -> Elt.t)
                                   Bin_prot.Read.reader
                                 val bin_reader_t :
                                   Elt.t Bin_prot.Type_class.reader
                                 val bin_size_t : Elt.t Bin_prot.Size.sizer
                                 val bin_write_t :
                                   Elt.t Bin_prot.Write.writer
                                 val bin_writer_t :
                                   Elt.t Bin_prot.Type_class.writer
                                 val bin_shape_t : Bin_prot.Shape.t
                               end->
                        sig
                          val bin_size_t : t Bin_prot.Size.sizer
                          val bin_write_t : t Bin_prot.Write.writer
                          val bin_read_t : t Bin_prot.Read.reader
                          val __bin_read_t__ :
                            (int -> t) Bin_prot.Read.reader
                          val bin_shape_t : Bin_prot.Shape.t
                          val bin_writer_t : t Bin_prot.Type_class.writer
                          val bin_reader_t : t Bin_prot.Type_class.reader
                          val bin_t : t Bin_prot.Type_class.t
                        end
                    module Provide_hash :
                      functor
                        (Elt : sig
                                 val hash_fold_t :
                                   Base__.Hash.state ->
                                   Elt.t -> Base__.Hash.state
                               end->
                        sig
                          val hash_fold_t :
                            Ppx_hash_lib.Std.Hash.state ->
                            t -> Ppx_hash_lib.Std.Hash.state
                          val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                        end
                    val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                    val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  end
                val hash : t -> Core_kernel__.Import.int
                val compare : t -> t -> Core_kernel__.Import.int
                val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
                module Table :
                  sig
                    type key = t
                    type ('a, 'b) hashtbl = ('a, 'b) Edge.Table.hashtbl
                    type 'b t = (key, 'b) hashtbl
                    val sexp_of_t :
                      ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                    type ('a, 'b) t_ = 'b t
                    type 'a key_ = key
                    val hashable :
                      key Core_kernel__.Core_hashtbl_intf.Hashable.t
                    val invariant :
                      'Base__.Invariant_intf.inv ->
                      'a t Base__.Invariant_intf.inv
                    val create :
                      (key, 'b, unit -> 'b t)
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val of_alist :
                      (key, 'b,
                       (key * 'b) list ->
                       [ `Duplicate_key of key | `Ok of 'b t ])
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val of_alist_report_all_dups :
                      (key, 'b,
                       (key * 'b) list ->
                       [ `Duplicate_keys of key list | `Ok of 'b t ])
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val of_alist_or_error :
                      (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val of_alist_exn :
                      (key, 'b, (key * 'b) list -> 'b t)
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val of_alist_multi :
                      (key, 'b list, (key * 'b) list -> 'b list t)
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val create_mapped :
                      (key, 'b,
                       get_key:('-> key) ->
                       get_data:('-> 'b) ->
                       'r list ->
                       [ `Duplicate_keys of key list | `Ok of 'b t ])
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val create_with_key :
                      (key, 'r,
                       get_key:('-> key) ->
                       'r list ->
                       [ `Duplicate_keys of key list | `Ok of 'r t ])
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val create_with_key_or_error :
                      (key, 'r,
                       get_key:('-> key) ->
                       'r list -> 'r t Base__.Or_error.t)
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val create_with_key_exn :
                      (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val group :
                      (key, 'b,
                       get_key:('-> key) ->
                       get_data:('-> 'b) ->
                       combine:('-> '-> 'b) -> 'r list -> 'b t)
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                    val clear : 'a t -> unit
                    val copy : 'b t -> 'b t
                    val fold :
                      'b t ->
                      init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                    val iter_keys : 'a t -> f:(key -> unit) -> unit
                    val iter : 'b t -> f:('-> unit) -> unit
                    val iteri :
                      'b t -> f:(key:key -> data:'-> unit) -> unit
                    val iter_vals : 'b t -> f:('-> unit) -> unit
                    val existsi :
                      'b t -> f:(key:key -> data:'-> bool) -> bool
                    val exists : 'b t -> f:('-> bool) -> bool
                    val for_alli :
                      'b t -> f:(key:key -> data:'-> bool) -> bool
                    val for_all : 'b t -> f:('-> bool) -> bool
                    val counti :
                      'b t -> f:(key:key -> data:'-> bool) -> int
                    val count : 'b t -> f:('-> bool) -> int
                    val length : 'a t -> int
                    val is_empty : 'a t -> bool
                    val mem : 'a t -> key -> bool
                    val remove : 'a t -> key -> unit
                    val replace : 'b t -> key:key -> data:'-> unit
                    val set : 'b t -> key:key -> data:'-> unit
                    val add :
                      'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                    val add_or_error :
                      'b t -> key:key -> data:'-> unit Base__.Or_error.t
                    val add_exn : 'b t -> key:key -> data:'-> unit
                    val change :
                      'b t -> key -> f:('b option -> 'b option) -> unit
                    val update : 'b t -> key -> f:('b option -> 'b) -> unit
                    val add_multi : 'b list t -> key:key -> data:'-> unit
                    val remove_multi : 'a list t -> key -> unit
                    val map : 'b t -> f:('-> 'c) -> 'c t
                    val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                    val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                    val filter_mapi :
                      'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                    val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                    val filter : 'b t -> f:('-> bool) -> 'b t
                    val filteri :
                      'b t -> f:(key:key -> data:'-> bool) -> 'b t
                    val partition_map :
                      'b t ->
                      f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                    val partition_mapi :
                      'b t ->
                      f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                      'c t * 'd t
                    val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
                    val partitioni_tf :
                      'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                    val find_or_add :
                      'b t -> key -> default:(unit -> 'b) -> 'b
                    val find : 'b t -> key -> 'b option
                    val find_exn : 'b t -> key -> 'b
                    val find_and_call :
                      'b t ->
                      key ->
                      if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                    val find_and_remove : 'b t -> key -> 'b option
                    val merge :
                      'a t ->
                      'b t ->
                      f:(key:key ->
                         [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                         'c option) ->
                      'c t
                    type 'a merge_into_action = Remove | Set_to of 'a
                    val merge_into :
                      src:'a t ->
                      dst:'b t ->
                      f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                      unit
                    val keys : 'a t -> key list
                    val data : 'b t -> 'b list
                    val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
                    val filter_inplace : 'b t -> f:('-> bool) -> unit
                    val filteri_inplace :
                      'b t -> f:(key:key -> data:'-> bool) -> unit
                    val map_inplace : 'b t -> f:('-> 'b) -> unit
                    val mapi_inplace :
                      'b t -> f:(key:key -> data:'-> 'b) -> unit
                    val filter_map_inplace :
                      'b t -> f:('-> 'b option) -> unit
                    val filter_mapi_inplace :
                      'b t -> f:(key:key -> data:'-> 'b option) -> unit
                    val replace_all : 'b t -> f:('-> 'b) -> unit
                    val replace_alli :
                      'b t -> f:(key:key -> data:'-> 'b) -> unit
                    val filter_replace_all :
                      'b t -> f:('-> 'b option) -> unit
                    val filter_replace_alli :
                      'b t -> f:(key:key -> data:'-> 'b option) -> unit
                    val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                    val similar :
                      'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                    val to_alist : 'b t -> (key * 'b) list
                    val validate :
                      name:(key -> string) ->
                      'Base__.Validate.check -> 'b t Base__.Validate.check
                    val incr :
                      ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                    val decr :
                      ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                    module Provide_of_sexp :
                      functor
                        (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                        sig
                          val t_of_sexp :
                            (Sexplib.Sexp.t -> 'v_x__001_) ->
                            Sexplib.Sexp.t -> 'v_x__001_ t
                        end
                    module Provide_bin_io :
                      functor
                        (Key : sig
                                 val bin_t : key Bin_prot.Type_class.t
                                 val bin_read_t : key Bin_prot.Read.reader
                                 val __bin_read_t__ :
                                   (Core_kernel__.Import.int -> key)
                                   Bin_prot.Read.reader
                                 val bin_reader_t :
                                   key Bin_prot.Type_class.reader
                                 val bin_size_t : key Bin_prot.Size.sizer
                                 val bin_write_t : key Bin_prot.Write.writer
                                 val bin_writer_t :
                                   key Bin_prot.Type_class.writer
                                 val bin_shape_t : Bin_prot.Shape.t
                               end->
                        sig
                          val bin_t :
                            'Bin_prot.Type_class.t ->
                            'a t Bin_prot.Type_class.t
                          val bin_read_t :
                            'Bin_prot.Read.reader ->
                            'a t Bin_prot.Read.reader
                          val __bin_read_t__ :
                            'Bin_prot.Read.reader ->
                            (Core_kernel__.Import.int -> 'a t)
                            Bin_prot.Read.reader
                          val bin_reader_t :
                            'Bin_prot.Type_class.reader ->
                            'a t Bin_prot.Type_class.reader
                          val bin_size_t :
                            'Bin_prot.Size.sizer ->
                            'a t Bin_prot.Size.sizer
                          val bin_write_t :
                            'Bin_prot.Write.writer ->
                            'a t Bin_prot.Write.writer
                          val bin_writer_t :
                            'Bin_prot.Type_class.writer ->
                            'a t Bin_prot.Type_class.writer
                          val bin_shape_t :
                            Bin_prot.Shape.t -> Bin_prot.Shape.t
                        end
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__002_) ->
                      Sexplib.Sexp.t -> 'v_x__002_ t
                  end
                module Hash_set :
                  sig
                    type elt = t
                    type t = elt Core_kernel__.Hash_set.t
                    val sexp_of_t : t -> Sexplib.Sexp.t
                    type 'a t_ = t
                    type 'a elt_ = elt
                    val create :
                      ('a, unit -> t)
                      Core_kernel__.Hash_set_intf.create_options_without_hashable
                    val of_list :
                      ('a, elt list -> t)
                      Core_kernel__.Hash_set_intf.create_options_without_hashable
                    module Provide_of_sexp :
                      functor
                        (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                        sig val t_of_sexp : Sexplib.Sexp.t -> t end
                    module Provide_bin_io :
                      functor
                        (X : sig
                               val bin_t : elt Bin_prot.Type_class.t
                               val bin_read_t : elt Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> elt)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 elt Bin_prot.Type_class.reader
                               val bin_size_t : elt Bin_prot.Size.sizer
                               val bin_write_t : elt Bin_prot.Write.writer
                               val bin_writer_t :
                                 elt Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                        sig
                          val bin_t : t Bin_prot.Type_class.t
                          val bin_read_t : t Bin_prot.Read.reader
                          val __bin_read_t__ :
                            (Core_kernel__.Import.int -> t)
                            Bin_prot.Read.reader
                          val bin_reader_t : t Bin_prot.Type_class.reader
                          val bin_size_t : t Bin_prot.Size.sizer
                          val bin_write_t : t Bin_prot.Write.writer
                          val bin_writer_t : t Bin_prot.Type_class.writer
                          val bin_shape_t : Bin_prot.Shape.t
                        end
                    val t_of_sexp : Sexplib.Sexp.t -> t
                  end
                module Hash_queue :
                  sig
                    module Key :
                      sig
                        type t = Hash_set.elt
                        val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                        val compare : t -> t -> int
                        val hash : t -> int
                      end
                    type 'a t
                    val sexp_of_t :
                      ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                    val length : 'a t -> int
                    val is_empty : 'a t -> bool
                    val iter : 'a t -> f:('-> unit) -> unit
                    val fold :
                      'a t ->
                      init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                    val fold_result :
                      'a t ->
                      init:'accum ->
                      f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                      ('accum, 'e) Base__.Result.t
                    val fold_until :
                      'a t ->
                      init:'accum ->
                      f:('accum ->
                         '->
                         ('accum, 'stop)
                         Base.Container_intf.Continue_or_stop.t) ->
                      ('accum, 'stop)
                      Base.Container_intf.Finished_or_stopped_early.t
                    val exists : 'a t -> f:('-> bool) -> bool
                    val for_all : 'a t -> f:('-> bool) -> bool
                    val count : 'a t -> f:('-> bool) -> int
                    val sum :
                      (module Base__.Commutative_group.S with type t = 'sum) ->
                      'a t -> f:('-> 'sum) -> 'sum
                    val find : 'a t -> f:('-> bool) -> 'a option
                    val find_map : 'a t -> f:('-> 'b option) -> 'b option
                    val to_list : 'a t -> 'a list
                    val to_array : 'a t -> 'a array
                    val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
                    val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
                    val invariant : 'a t -> Core_kernel__.Import.unit
                    val create :
                      ?growth_allowed:Core_kernel__.Import.bool ->
                      ?size:Core_kernel__.Import.int ->
                      Core_kernel__.Import.unit -> 'a t
                    val clear : 'a t -> Core_kernel__.Import.unit
                    val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
                    val lookup :
                      'a t -> Key.t -> 'Core_kernel__.Import.option
                    val lookup_exn : 'a t -> Key.t -> 'a
                    val enqueue :
                      'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
                    val enqueue_exn :
                      'a t -> Key.t -> '-> Core_kernel__.Import.unit
                    val lookup_and_move_to_back :
                      'a t -> Key.t -> 'Core_kernel__.Import.option
                    val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
                    val first : 'a t -> 'Core_kernel__.Import.option
                    val first_with_key :
                      'a t -> (Key.t * 'a) Core_kernel__.Import.option
                    val keys : 'a t -> Key.t Core_kernel__.Import.list
                    val dequeue : 'a t -> 'Core_kernel__.Import.option
                    val dequeue_exn : 'a t -> 'a
                    val dequeue_with_key :
                      'a t -> (Key.t * 'a) Core_kernel__.Import.option
                    val dequeue_with_key_exn : 'a t -> Key.t * 'a
                    val dequeue_all :
                      'a t ->
                      f:('-> Core_kernel__.Import.unit) ->
                      Core_kernel__.Import.unit
                    val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
                    val remove_exn :
                      'a t -> Key.t -> Core_kernel__.Import.unit
                    val replace :
                      'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
                    val replace_exn :
                      'a t -> Key.t -> '-> Core_kernel__.Import.unit
                    val iteri :
                      'a t ->
                      f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                      Core_kernel__.Import.unit
                    val foldi :
                      'a t ->
                      init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
                  end
                val to_string : t -> string
                val str : unit -> t -> string
                val pps : unit -> t -> string
                val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
                val pp_seq :
                  Format.formatter -> t Core_kernel.Std.Sequence.t -> unit
                val pp : Base__.Import.Caml.Format.formatter -> t -> unit
              end
          module Labeled :
            functor
              (Node : Regular.Std.Opaque.S) (NL : Core_kernel.Std.T) (EL : Core_kernel.Std.T->
              sig
                type t
                type node = (Node.t, NL.t) labeled
                type edge
                module Node :
                  sig
                    type t = node
                    type graph = t
                    type label = (Node.t, NL.t) labeled
                    type edge = edge
                    val create : label -> t
                    val label : t -> label
                    val mem : t -> graph -> bool
                    val succs : t -> graph -> t Regular.Std.seq
                    val preds : t -> graph -> t Regular.Std.seq
                    val inputs : t -> graph -> edge Regular.Std.seq
                    val outputs : t -> graph -> edge Regular.Std.seq
                    val degree : ?dir:[ `In | `Out ] -> t -> graph -> int
                    val insert : t -> graph -> graph
                    val update : t -> label -> graph -> graph
                    val remove : t -> graph -> graph
                    val has_edge : t -> t -> graph -> bool
                    val edge : t -> t -> graph -> edge option
                    val ( >= ) : t -> t -> bool
                    val ( <= ) : t -> t -> bool
                    val ( = ) : t -> t -> bool
                    val ( > ) : t -> t -> bool
                    val ( < ) : t -> t -> bool
                    val ( <> ) : t -> t -> bool
                    val equal : t -> t -> bool
                    val min : t -> t -> t
                    val max : t -> t -> t
                    val ascending : t -> t -> int
                    val descending : t -> t -> int
                    val between : t -> low:t -> high:t -> bool
                    val clamp_exn : t -> min:t -> max:t -> t
                    val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
                    type comparator_witness
                    val comparator :
                      (t, comparator_witness) Base__.Comparator.comparator
                    val validate_lbound :
                      min:t Base__.Maybe_bound.t -> t Base__.Validate.check
                    val validate_ubound :
                      max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                    val validate_bound :
                      min:t Base__.Maybe_bound.t ->
                      max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                    module Replace_polymorphic_compare :
                      sig
                        val ( >= ) : t -> t -> bool
                        val ( <= ) : t -> t -> bool
                        val ( = ) : t -> t -> bool
                        val ( > ) : t -> t -> bool
                        val ( < ) : t -> t -> bool
                        val ( <> ) : t -> t -> bool
                        val equal : t -> t -> bool
                        val compare : t -> t -> int
                        val min : t -> t -> t
                        val max : t -> t -> t
                      end
                    module Map :
                      sig
                        module Key :
                          sig
                            type t = node
                            val t_of_sexp : Sexplib.Sexp.t -> t
                            val sexp_of_t : t -> Sexplib.Sexp.t
                            type comparator_witness = comparator_witness
                            val comparator :
                              (t, comparator_witness)
                              Core_kernel__.Comparator.comparator
                          end
                        module Tree :
                          sig
                            type 'a t =
                                (node, 'a, comparator_witness)
                                Core_kernel__.Core_map_intf.Tree.t
                            val empty : 'a t
                            val singleton : node -> '-> 'a t
                            val of_alist :
                              (node * 'a) list ->
                              [ `Duplicate_key of node | `Ok of 'a t ]
                            val of_alist_or_error :
                              (node * 'a) list -> 'a t Base__.Or_error.t
                            val of_alist_exn : (node * 'a) list -> 'a t
                            val of_alist_multi :
                              (node * 'a) list -> 'a list t
                            val of_alist_fold :
                              (node * 'a) list ->
                              init:'-> f:('-> '-> 'b) -> 'b t
                            val of_alist_reduce :
                              (node * 'a) list -> f:('-> '-> 'a) -> 'a t
                            val of_sorted_array :
                              (node * 'a) array -> 'a t Base__.Or_error.t
                            val of_sorted_array_unchecked :
                              (node * 'a) array -> 'a t
                            val of_increasing_iterator_unchecked :
                              len:int -> f:(int -> node * 'a) -> 'a t
                            val of_iteri :
                              iteri:(f:(key:node -> data:'-> unit) -> unit) ->
                              [ `Duplicate_key of node | `Ok of 'v t ]
                            val of_tree : 'a t -> 'a t
                            val of_hashtbl_exn :
                              (node, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                            val gen :
                              node Core_kernel__.Quickcheck.Generator.t ->
                              'Core_kernel__.Quickcheck.Generator.t ->
                              'a t Core_kernel__.Quickcheck.Generator.t
                            val invariants : 'a t -> bool
                            val is_empty : 'a t -> bool
                            val length : 'a t -> int
                            val add : 'a t -> key:node -> data:'-> 'a t
                            val add_multi :
                              'a list t -> key:node -> data:'-> 'a list t
                            val remove_multi : 'a list t -> node -> 'a list t
                            val change :
                              'a t ->
                              node -> f:('a option -> 'a option) -> 'a t
                            val update :
                              'a t -> node -> f:('a option -> 'a) -> 'a t
                            val find : 'a t -> node -> 'a option
                            val find_exn : 'a t -> node -> 'a
                            val remove : 'a t -> node -> 'a t
                            val mem : 'a t -> node -> bool
                            val iter_keys : 'a t -> f:(node -> unit) -> unit
                            val iter : 'a t -> f:('-> unit) -> unit
                            val iteri :
                              'a t -> f:(key:node -> data:'-> unit) -> unit
                            val iter2 :
                              'a t ->
                              'b t ->
                              f:(key:node ->
                                 data:[ `Both of 'a * 'b
                                      | `Left of 'a
                                      | `Right of 'b ] ->
                                 unit) ->
                              unit
                            val map : 'a t -> f:('-> 'b) -> 'b t
                            val mapi :
                              'a t -> f:(key:node -> data:'-> 'b) -> 'b t
                            val fold :
                              'a t ->
                              init:'->
                              f:(key:node -> data:'-> '-> 'b) -> 'b
                            val fold_right :
                              'a t ->
                              init:'->
                              f:(key:node -> data:'-> '-> 'b) -> 'b
                            val fold2 :
                              'a t ->
                              'b t ->
                              init:'->
                              f:(key:node ->
                                 data:[ `Both of 'a * 'b
                                      | `Left of 'a
                                      | `Right of 'b ] ->
                                 '-> 'c) ->
                              'c
                            val filter_keys :
                              'a t -> f:(node -> bool) -> 'a t
                            val filter : 'a t -> f:('-> bool) -> 'a t
                            val filteri :
                              'a t -> f:(key:node -> data:'-> bool) -> 'a t
                            val filter_map :
                              'a t -> f:('-> 'b option) -> 'b t
                            val filter_mapi :
                              'a t ->
                              f:(key:node -> data:'-> 'b option) -> 'b t
                            val partition_mapi :
                              'a t ->
                              f:(key:node ->
                                 data:'-> [ `Fst of '| `Snd of 'c ]) ->
                              'b t * 'c t
                            val partition_map :
                              'a t ->
                              f:('-> [ `Fst of '| `Snd of 'c ]) ->
                              'b t * 'c t
                            val partitioni_tf :
                              'a t ->
                              f:(key:node -> data:'-> bool) -> 'a t * 'a t
                            val partition_tf :
                              'a t -> f:('-> bool) -> 'a t * 'a t
                            val compare_direct :
                              ('-> '-> int) -> 'a t -> 'a t -> int
                            val equal :
                              ('-> '-> bool) -> 'a t -> 'a t -> bool
                            val keys : 'a t -> node list
                            val data : 'a t -> 'a list
                            val to_alist :
                              ?key_order:[ `Decreasing | `Increasing ] ->
                              'a t -> (node * 'a) list
                            val validate :
                              name:(node -> string) ->
                              'Base__.Validate.check ->
                              'a t Base__.Validate.check
                            val merge :
                              'a t ->
                              'b t ->
                              f:(key:node ->
                                 [ `Both of 'a * 'b
                                 | `Left of 'a
                                 | `Right of 'b ] -> 'c option) ->
                              'c t
                            val symmetric_diff :
                              'a t ->
                              'a t ->
                              data_equal:('-> '-> bool) ->
                              (node, 'a)
                              Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                              Base__.Sequence.t
                            val min_elt : 'a t -> (node * 'a) option
                            val min_elt_exn : 'a t -> node * 'a
                            val max_elt : 'a t -> (node * 'a) option
                            val max_elt_exn : 'a t -> node * 'a
                            val for_all : 'a t -> f:('-> bool) -> bool
                            val for_alli :
                              'a t -> f:(key:node -> data:'-> bool) -> bool
                            val exists : 'a t -> f:('-> bool) -> bool
                            val existsi :
                              'a t -> f:(key:node -> data:'-> bool) -> bool
                            val count : 'a t -> f:('-> bool) -> int
                            val counti :
                              'a t -> f:(key:node -> data:'-> bool) -> int
                            val split :
                              'a t ->
                              node -> 'a t * (node * 'a) option * 'a t
                            val append :
                              lower_part:'a t ->
                              upper_part:'a t ->
                              [ `Ok of 'a t | `Overlapping_key_ranges ]
                            val subrange :
                              'a t ->
                              lower_bound:node Base__.Maybe_bound.t ->
                              upper_bound:node Base__.Maybe_bound.t -> 'a t
                            val fold_range_inclusive :
                              'a t ->
                              min:node ->
                              max:node ->
                              init:'->
                              f:(key:node -> data:'-> '-> 'b) -> 'b
                            val range_to_alist :
                              'a t ->
                              min:node -> max:node -> (node * 'a) list
                            val closest_key :
                              'a t ->
                              [ `Greater_or_equal_to
                              | `Greater_than
                              | `Less_or_equal_to
                              | `Less_than ] -> node -> (node * 'a) option
                            val nth : 'a t -> int -> (node * 'a) option
                            val nth_exn : 'a t -> int -> node * 'a
                            val rank : 'a t -> node -> int option
                            val to_tree : 'a t -> 'a t
                            val to_sequence :
                              ?order:[ `Decreasing_key | `Increasing_key ] ->
                              ?keys_greater_or_equal_to:node ->
                              ?keys_less_or_equal_to:node ->
                              'a t -> (node * 'a) Base__.Sequence.t
                            val obs :
                              node Core_kernel__.Quickcheck.Observer.t ->
                              'Core_kernel__.Quickcheck.Observer.t ->
                              'v t Core_kernel__.Quickcheck.Observer.t
                            val shrinker :
                              node Core_kernel__.Quickcheck.Shrinker.t ->
                              'Core_kernel__.Quickcheck.Shrinker.t ->
                              'v t Core_kernel__.Quickcheck.Shrinker.t
                            module Provide_of_sexp :
                              functor
                                (K : sig
                                       val t_of_sexp : Sexplib.Sexp.t -> node
                                     end->
                                sig
                                  val t_of_sexp :
                                    (Sexplib.Sexp.t -> 'v_x__017_) ->
                                    Sexplib.Sexp.t -> 'v_x__017_ t
                                end
                            val t_of_sexp :
                              (Base__.Sexplib.Sexp.t -> 'a) ->
                              Base__.Sexplib.Sexp.t -> 'a t
                            val sexp_of_t :
                              ('-> Base__.Sexplib.Sexp.t) ->
                              'a t -> Base__.Sexplib.Sexp.t
                          end
                        type 'a t =
                            (node, 'a, comparator_witness)
                            Core_kernel__.Core_map_intf.Map.t
                        val compare :
                          ('-> '-> Core_kernel__.Import.int) ->
                          'a t -> 'a t -> Core_kernel__.Import.int
                        val empty : 'a t
                        val singleton : node -> '-> 'a t
                        val of_alist :
                          (node * 'a) list ->
                          [ `Duplicate_key of node | `Ok of 'a t ]
                        val of_alist_or_error :
                          (node * 'a) list -> 'a t Base__.Or_error.t
                        val of_alist_exn : (node * 'a) list -> 'a t
                        val of_alist_multi : (node * 'a) list -> 'a list t
                        val of_alist_fold :
                          (node * 'a) list ->
                          init:'-> f:('-> '-> 'b) -> 'b t
                        val of_alist_reduce :
                          (node * 'a) list -> f:('-> '-> 'a) -> 'a t
                        val of_sorted_array :
                          (node * 'a) array -> 'a t Base__.Or_error.t
                        val of_sorted_array_unchecked :
                          (node * 'a) array -> 'a t
                        val of_increasing_iterator_unchecked :
                          len:int -> f:(int -> node * 'a) -> 'a t
                        val of_iteri :
                          iteri:(f:(key:node -> data:'-> unit) -> unit) ->
                          [ `Duplicate_key of node | `Ok of 'v t ]
                        val of_tree : 'Tree.t -> 'a t
                        val of_hashtbl_exn :
                          (node, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                        val gen :
                          node Core_kernel__.Quickcheck.Generator.t ->
                          'Core_kernel__.Quickcheck.Generator.t ->
                          'a t Core_kernel__.Quickcheck.Generator.t
                        val invariants : 'a t -> bool
                        val is_empty : 'a t -> bool
                        val length : 'a t -> int
                        val add : 'a t -> key:node -> data:'-> 'a t
                        val add_multi :
                          'a list t -> key:node -> data:'-> 'a list t
                        val remove_multi : 'a list t -> node -> 'a list t
                        val change :
                          'a t -> node -> f:('a option -> 'a option) -> 'a t
                        val update :
                          'a t -> node -> f:('a option -> 'a) -> 'a t
                        val find : 'a t -> node -> 'a option
                        val find_exn : 'a t -> node -> 'a
                        val remove : 'a t -> node -> 'a t
                        val mem : 'a t -> node -> bool
                        val iter_keys : 'a t -> f:(node -> unit) -> unit
                        val iter : 'a t -> f:('-> unit) -> unit
                        val iteri :
                          'a t -> f:(key:node -> data:'-> unit) -> unit
                        val iter2 :
                          'a t ->
                          'b t ->
                          f:(key:node ->
                             data:[ `Both of 'a * 'b
                                  | `Left of 'a
                                  | `Right of 'b ] ->
                             unit) ->
                          unit
                        val map : 'a t -> f:('-> 'b) -> 'b t
                        val mapi :
                          'a t -> f:(key:node -> data:'-> 'b) -> 'b t
                        val fold :
                          'a t ->
                          init:'->
                          f:(key:node -> data:'-> '-> 'b) -> 'b
                        val fold_right :
                          'a t ->
                          init:'->
                          f:(key:node -> data:'-> '-> 'b) -> 'b
                        val fold2 :
                          'a t ->
                          'b t ->
                          init:'->
                          f:(key:node ->
                             data:[ `Both of 'a * 'b
                                  | `Left of 'a
                                  | `Right of 'b ] ->
                             '-> 'c) ->
                          'c
                        val filter_keys : 'a t -> f:(node -> bool) -> 'a t
                        val filter : 'a t -> f:('-> bool) -> 'a t
                        val filteri :
                          'a t -> f:(key:node -> data:'-> bool) -> 'a t
                        val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                        val filter_mapi :
                          'a t ->
                          f:(key:node -> data:'-> 'b option) -> 'b t
                        val partition_mapi :
                          'a t ->
                          f:(key:node ->
                             data:'-> [ `Fst of '| `Snd of 'c ]) ->
                          'b t * 'c t
                        val partition_map :
                          'a t ->
                          f:('-> [ `Fst of '| `Snd of 'c ]) ->
                          'b t * 'c t
                        val partitioni_tf :
                          'a t ->
                          f:(key:node -> data:'-> bool) -> 'a t * 'a t
                        val partition_tf :
                          'a t -> f:('-> bool) -> 'a t * 'a t
                        val compare_direct :
                          ('-> '-> int) -> 'a t -> 'a t -> int
                        val equal :
                          ('-> '-> bool) -> 'a t -> 'a t -> bool
                        val keys : 'a t -> node list
                        val data : 'a t -> 'a list
                        val to_alist :
                          ?key_order:[ `Decreasing | `Increasing ] ->
                          'a t -> (node * 'a) list
                        val validate :
                          name:(node -> string) ->
                          'Base__.Validate.check ->
                          'a t Base__.Validate.check
                        val merge :
                          'a t ->
                          'b t ->
                          f:(key:node ->
                             [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                             'c option) ->
                          'c t
                        val symmetric_diff :
                          'a t ->
                          'a t ->
                          data_equal:('-> '-> bool) ->
                          (node, 'a)
                          Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                          Base__.Sequence.t
                        val min_elt : 'a t -> (node * 'a) option
                        val min_elt_exn : 'a t -> node * 'a
                        val max_elt : 'a t -> (node * 'a) option
                        val max_elt_exn : 'a t -> node * 'a
                        val for_all : 'a t -> f:('-> bool) -> bool
                        val for_alli :
                          'a t -> f:(key:node -> data:'-> bool) -> bool
                        val exists : 'a t -> f:('-> bool) -> bool
                        val existsi :
                          'a t -> f:(key:node -> data:'-> bool) -> bool
                        val count : 'a t -> f:('-> bool) -> int
                        val counti :
                          'a t -> f:(key:node -> data:'-> bool) -> int
                        val split :
                          'a t -> node -> 'a t * (node * 'a) option * 'a t
                        val append :
                          lower_part:'a t ->
                          upper_part:'a t ->
                          [ `Ok of 'a t | `Overlapping_key_ranges ]
                        val subrange :
                          'a t ->
                          lower_bound:node Base__.Maybe_bound.t ->
                          upper_bound:node Base__.Maybe_bound.t -> 'a t
                        val fold_range_inclusive :
                          'a t ->
                          min:node ->
                          max:node ->
                          init:'->
                          f:(key:node -> data:'-> '-> 'b) -> 'b
                        val range_to_alist :
                          'a t -> min:node -> max:node -> (node * 'a) list
                        val closest_key :
                          'a t ->
                          [ `Greater_or_equal_to
                          | `Greater_than
                          | `Less_or_equal_to
                          | `Less_than ] -> node -> (node * 'a) option
                        val nth : 'a t -> int -> (node * 'a) option
                        val nth_exn : 'a t -> int -> node * 'a
                        val rank : 'a t -> node -> int option
                        val to_tree : 'a t -> 'Tree.t
                        val to_sequence :
                          ?order:[ `Decreasing_key | `Increasing_key ] ->
                          ?keys_greater_or_equal_to:node ->
                          ?keys_less_or_equal_to:node ->
                          'a t -> (node * 'a) Base__.Sequence.t
                        val obs :
                          node Core_kernel__.Quickcheck.Observer.t ->
                          'Core_kernel__.Quickcheck.Observer.t ->
                          'v t Core_kernel__.Quickcheck.Observer.t
                        val shrinker :
                          node Core_kernel__.Quickcheck.Shrinker.t ->
                          'Core_kernel__.Quickcheck.Shrinker.t ->
                          'v t Core_kernel__.Quickcheck.Shrinker.t
                        module Provide_of_sexp :
                          functor
                            (Key : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> node
                                   end->
                            sig
                              val t_of_sexp :
                                (Sexplib.Sexp.t -> 'v_x__018_) ->
                                Sexplib.Sexp.t -> 'v_x__018_ t
                            end
                        module Provide_bin_io :
                          functor
                            (Key : sig
                                     val bin_t : node Bin_prot.Type_class.t
                                     val bin_read_t :
                                       node Bin_prot.Read.reader
                                     val __bin_read_t__ :
                                       (Core_kernel__.Import.int -> node)
                                       Bin_prot.Read.reader
                                     val bin_reader_t :
                                       node Bin_prot.Type_class.reader
                                     val bin_size_t :
                                       node Bin_prot.Size.sizer
                                     val bin_write_t :
                                       node Bin_prot.Write.writer
                                     val bin_writer_t :
                                       node Bin_prot.Type_class.writer
                                     val bin_shape_t : Bin_prot.Shape.t
                                   end->
                            sig
                              val bin_shape_t :
                                Bin_prot.Shape.t -> Bin_prot.Shape.t
                              val bin_size_t :
                                ('a, 'a t) Bin_prot.Size.sizer1
                              val bin_write_t :
                                ('a, 'a t) Bin_prot.Write.writer1
                              val bin_read_t :
                                ('a, 'a t) Bin_prot.Read.reader1
                              val __bin_read_t__ :
                                ('a, int -> 'a t) Bin_prot.Read.reader1
                              val bin_writer_t :
                                ('a, 'a t) Bin_prot.Type_class.S1.writer
                              val bin_reader_t :
                                ('a, 'a t) Bin_prot.Type_class.S1.reader
                              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                            end
                        module Provide_hash :
                          functor
                            (Key : sig
                                     val hash_fold_t :
                                       Base__.Hash.state ->
                                       node -> Base__.Hash.state
                                   end->
                            sig
                              val hash_fold_t :
                                (Ppx_hash_lib.Std.Hash.state ->
                                 '-> Ppx_hash_lib.Std.Hash.state) ->
                                Ppx_hash_lib.Std.Hash.state ->
                                'a t -> Ppx_hash_lib.Std.Hash.state
                            end
                        val t_of_sexp :
                          (Base__.Sexplib.Sexp.t -> 'a) ->
                          Base__.Sexplib.Sexp.t -> 'a t
                        val sexp_of_t :
                          ('-> Base__.Sexplib.Sexp.t) ->
                          'a t -> Base__.Sexplib.Sexp.t
                      end
                    module Set :
                      sig
                        module Elt :
                          sig
                            type t = node
                            val t_of_sexp : Sexplib.Sexp.t -> t
                            val sexp_of_t : t -> Sexplib.Sexp.t
                            type comparator_witness =
                                Map.Key.comparator_witness
                            val comparator :
                              (t, comparator_witness)
                              Core_kernel__.Comparator.comparator
                          end
                        module Tree :
                          sig
                            type t =
                                (node, comparator_witness)
                                Core_kernel__.Core_set_intf.Tree.t
                            val compare : t -> t -> Core_kernel__.Import.int
                            val length : t -> int
                            val is_empty : t -> bool
                            val iter : t -> f:(node -> unit) -> unit
                            val fold :
                              t ->
                              init:'accum ->
                              f:('accum -> node -> 'accum) -> 'accum
                            val fold_result :
                              t ->
                              init:'accum ->
                              f:('accum ->
                                 node -> ('accum, 'e) Base__.Result.t) ->
                              ('accum, 'e) Base__.Result.t
                            val exists : t -> f:(node -> bool) -> bool
                            val for_all : t -> f:(node -> bool) -> bool
                            val count : t -> f:(node -> bool) -> int
                            val sum :
                              (module Base__.Commutative_group.S with type t = 'sum) ->
                              t -> f:(node -> 'sum) -> 'sum
                            val find : t -> f:(node -> bool) -> node option
                            val find_map :
                              t -> f:(node -> 'a option) -> 'a option
                            val to_list : t -> node list
                            val to_array : t -> node array
                            val invariants : t -> bool
                            val mem : t -> node -> bool
                            val add : t -> node -> t
                            val remove : t -> node -> t
                            val union : t -> t -> t
                            val inter : t -> t -> t
                            val diff : t -> t -> t
                            val symmetric_diff :
                              t ->
                              t ->
                              (node, node) Base__.Either.t Base__.Sequence.t
                            val compare_direct : t -> t -> int
                            val equal : t -> t -> bool
                            val is_subset : t -> of_:t -> bool
                            val subset : t -> t -> bool
                            val fold_until :
                              t ->
                              init:'->
                              f:('->
                                 node ->
                                 ('b, 'stop)
                                 Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                              ('b, 'stop)
                              Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                            val fold_right :
                              t -> init:'-> f:(node -> '-> 'b) -> 'b
                            val iter2 :
                              t ->
                              t ->
                              f:([ `Both of node * node
                                 | `Left of node
                                 | `Right of node ] -> unit) ->
                              unit
                            val filter : t -> f:(node -> bool) -> t
                            val partition_tf : t -> f:(node -> bool) -> t * t
                            val elements : t -> node list
                            val min_elt : t -> node option
                            val min_elt_exn : t -> node
                            val max_elt : t -> node option
                            val max_elt_exn : t -> node
                            val choose : t -> node option
                            val choose_exn : t -> node
                            val split : t -> node -> t * node option * t
                            val group_by :
                              t -> equiv:(node -> node -> bool) -> t list
                            val find_exn : t -> f:(node -> bool) -> node
                            val find_index : t -> int -> node option
                            val nth : t -> int -> node option
                            val remove_index : t -> int -> t
                            val to_tree : t -> t
                            val to_sequence :
                              ?order:[ `Decreasing | `Increasing ] ->
                              ?greater_or_equal_to:node ->
                              ?less_or_equal_to:node ->
                              t -> node Base__.Sequence.t
                            val merge_to_sequence :
                              ?order:[ `Decreasing | `Increasing ] ->
                              ?greater_or_equal_to:node ->
                              ?less_or_equal_to:node ->
                              t ->
                              t ->
                              (node, node)
                              Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                              Base__.Sequence.t
                            val to_map :
                              t ->
                              f:(node -> 'data) ->
                              (node, 'data, comparator_witness)
                              Core_kernel__.Core_set_intf.Map.t
                            val obs :
                              node Core_kernel__.Quickcheck.Observer.t ->
                              t Core_kernel__.Quickcheck.Observer.t
                            val shrinker :
                              node Core_kernel__.Quickcheck.Shrinker.t ->
                              t Core_kernel__.Quickcheck.Shrinker.t
                            val empty : t
                            val singleton : node -> t
                            val union_list : t list -> t
                            val of_list : node list -> t
                            val of_array : node array -> t
                            val of_sorted_array :
                              node array -> t Base__.Or_error.t
                            val of_sorted_array_unchecked : node array -> t
                            val of_increasing_iterator_unchecked :
                              len:int -> f:(int -> node) -> t
                            val stable_dedup_list : node list -> node list
                            val map :
                              ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                              f:('-> node) -> t
                            val filter_map :
                              ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                              f:('-> node option) -> t
                            val of_tree : t -> t
                            val of_hash_set :
                              node Core_kernel__.Hash_set.t -> t
                            val of_hashtbl_keys :
                              (node, 'a) Core_kernel__.Core_hashtbl.t -> t
                            val of_map_keys :
                              (node, 'a, comparator_witness)
                              Core_kernel__.Core_set_intf.Map.t -> t
                            val gen :
                              node Core_kernel__.Quickcheck.Generator.t ->
                              t Core_kernel__.Quickcheck.Generator.t
                            module Provide_of_sexp :
                              functor
                                (Elt : sig
                                         val t_of_sexp :
                                           Sexplib.Sexp.t -> node
                                       end->
                                sig val t_of_sexp : Sexplib.Sexp.t -> t end
                            val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                            val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                          end
                        type t = (node, comparator_witness) Base.Set.t
                        val compare : t -> t -> Core_kernel__.Import.int
                        val length : t -> int
                        val is_empty : t -> bool
                        val iter : t -> f:(node -> unit) -> unit
                        val fold :
                          t ->
                          init:'accum ->
                          f:('accum -> node -> 'accum) -> 'accum
                        val fold_result :
                          t ->
                          init:'accum ->
                          f:('accum -> node -> ('accum, 'e) Base__.Result.t) ->
                          ('accum, 'e) Base__.Result.t
                        val exists : t -> f:(node -> bool) -> bool
                        val for_all : t -> f:(node -> bool) -> bool
                        val count : t -> f:(node -> bool) -> int
                        val sum :
                          (module Base__.Commutative_group.S with type t = 'sum) ->
                          t -> f:(node -> 'sum) -> 'sum
                        val find : t -> f:(node -> bool) -> node option
                        val find_map :
                          t -> f:(node -> 'a option) -> 'a option
                        val to_list : t -> node list
                        val to_array : t -> node array
                        val invariants : t -> bool
                        val mem : t -> node -> bool
                        val add : t -> node -> t
                        val remove : t -> node -> t
                        val union : t -> t -> t
                        val inter : t -> t -> t
                        val diff : t -> t -> t
                        val symmetric_diff :
                          t ->
                          t -> (node, node) Base__.Either.t Base__.Sequence.t
                        val compare_direct : t -> t -> int
                        val equal : t -> t -> bool
                        val is_subset : t -> of_:t -> bool
                        val subset : t -> t -> bool
                        val fold_until :
                          t ->
                          init:'->
                          f:('->
                             node ->
                             ('b, 'stop)
                             Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                          ('b, 'stop)
                          Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                        val fold_right :
                          t -> init:'-> f:(node -> '-> 'b) -> 'b
                        val iter2 :
                          t ->
                          t ->
                          f:([ `Both of node * node
                             | `Left of node
                             | `Right of node ] -> unit) ->
                          unit
                        val filter : t -> f:(node -> bool) -> t
                        val partition_tf : t -> f:(node -> bool) -> t * t
                        val elements : t -> node list
                        val min_elt : t -> node option
                        val min_elt_exn : t -> node
                        val max_elt : t -> node option
                        val max_elt_exn : t -> node
                        val choose : t -> node option
                        val choose_exn : t -> node
                        val split : t -> node -> t * node option * t
                        val group_by :
                          t -> equiv:(node -> node -> bool) -> t list
                        val find_exn : t -> f:(node -> bool) -> node
                        val find_index : t -> int -> node option
                        val nth : t -> int -> node option
                        val remove_index : t -> int -> t
                        val to_tree : t -> Tree.t
                        val to_sequence :
                          ?order:[ `Decreasing | `Increasing ] ->
                          ?greater_or_equal_to:node ->
                          ?less_or_equal_to:node ->
                          t -> node Base__.Sequence.t
                        val merge_to_sequence :
                          ?order:[ `Decreasing | `Increasing ] ->
                          ?greater_or_equal_to:node ->
                          ?less_or_equal_to:node ->
                          t ->
                          t ->
                          (node, node)
                          Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                          Base__.Sequence.t
                        val to_map :
                          t ->
                          f:(node -> 'data) ->
                          (node, 'data, comparator_witness)
                          Core_kernel__.Core_set_intf.Map.t
                        val obs :
                          node Core_kernel__.Quickcheck.Observer.t ->
                          t Core_kernel__.Quickcheck.Observer.t
                        val shrinker :
                          node Core_kernel__.Quickcheck.Shrinker.t ->
                          t Core_kernel__.Quickcheck.Shrinker.t
                        val empty : t
                        val singleton : node -> t
                        val union_list : t list -> t
                        val of_list : node list -> t
                        val of_array : node array -> t
                        val of_sorted_array :
                          node array -> t Base__.Or_error.t
                        val of_sorted_array_unchecked : node array -> t
                        val of_increasing_iterator_unchecked :
                          len:int -> f:(int -> node) -> t
                        val stable_dedup_list : node list -> node list
                        val map : ('a, 'b) Base.Set.t -> f:('-> node) -> t
                        val filter_map :
                          ('a, 'b) Base.Set.t -> f:('-> node option) -> t
                        val of_tree : Tree.t -> t
                        val of_hash_set : node Core_kernel__.Hash_set.t -> t
                        val of_hashtbl_keys :
                          (node, 'a) Core_kernel__.Core_hashtbl.t -> t
                        val of_map_keys :
                          (node, 'a, comparator_witness)
                          Core_kernel__.Core_set_intf.Map.t -> t
                        val gen :
                          node Core_kernel__.Quickcheck.Generator.t ->
                          t Core_kernel__.Quickcheck.Generator.t
                        module Provide_of_sexp :
                          functor
                            (Elt : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> node
                                   end->
                            sig val t_of_sexp : Sexplib.Sexp.t -> t end
                        module Provide_bin_io :
                          functor
                            (Elt : sig
                                     val bin_t : node Bin_prot.Type_class.t
                                     val bin_read_t :
                                       node Bin_prot.Read.reader
                                     val __bin_read_t__ :
                                       (Core_kernel__.Import.int -> node)
                                       Bin_prot.Read.reader
                                     val bin_reader_t :
                                       node Bin_prot.Type_class.reader
                                     val bin_size_t :
                                       node Bin_prot.Size.sizer
                                     val bin_write_t :
                                       node Bin_prot.Write.writer
                                     val bin_writer_t :
                                       node Bin_prot.Type_class.writer
                                     val bin_shape_t : Bin_prot.Shape.t
                                   end->
                            sig
                              val bin_size_t : t Bin_prot.Size.sizer
                              val bin_write_t : t Bin_prot.Write.writer
                              val bin_read_t : t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                (int -> t) Bin_prot.Read.reader
                              val bin_shape_t : Bin_prot.Shape.t
                              val bin_writer_t : t Bin_prot.Type_class.writer
                              val bin_reader_t : t Bin_prot.Type_class.reader
                              val bin_t : t Bin_prot.Type_class.t
                            end
                        module Provide_hash :
                          functor
                            (Elt : sig
                                     val hash_fold_t :
                                       Base__.Hash.state ->
                                       node -> Base__.Hash.state
                                   end->
                            sig
                              val hash_fold_t :
                                Ppx_hash_lib.Std.Hash.state ->
                                t -> Ppx_hash_lib.Std.Hash.state
                              val hash :
                                t -> Ppx_hash_lib.Std.Hash.hash_value
                            end
                        val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                        val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                      end
                    val hash : t -> Core_kernel__.Import.int
                    val compare : t -> t -> Core_kernel__.Import.int
                    val hashable :
                      t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
                    module Table :
                      sig
                        type key = t
                        type ('a, 'b) hashtbl = ('a, 'b) Equiv.Table.hashtbl
                        type 'b t = (key, 'b) hashtbl
                        val sexp_of_t :
                          ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                        type ('a, 'b) t_ = 'b t
                        type 'a key_ = key
                        val hashable :
                          key Core_kernel__.Core_hashtbl_intf.Hashable.t
                        val invariant :
                          'Base__.Invariant_intf.inv ->
                          'a t Base__.Invariant_intf.inv
                        val create :
                          (key, 'b, unit -> 'b t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist :
                          (key, 'b,
                           (key * 'b) list ->
                           [ `Duplicate_key of key | `Ok of 'b t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_report_all_dups :
                          (key, 'b,
                           (key * 'b) list ->
                           [ `Duplicate_keys of key list | `Ok of 'b t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_or_error :
                          (key, 'b,
                           (key * 'b) list -> 'b t Base__.Or_error.t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_exn :
                          (key, 'b, (key * 'b) list -> 'b t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_multi :
                          (key, 'b list, (key * 'b) list -> 'b list t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_mapped :
                          (key, 'b,
                           get_key:('-> key) ->
                           get_data:('-> 'b) ->
                           'r list ->
                           [ `Duplicate_keys of key list | `Ok of 'b t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_with_key :
                          (key, 'r,
                           get_key:('-> key) ->
                           'r list ->
                           [ `Duplicate_keys of key list | `Ok of 'r t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_with_key_or_error :
                          (key, 'r,
                           get_key:('-> key) ->
                           'r list -> 'r t Base__.Or_error.t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_with_key_exn :
                          (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val group :
                          (key, 'b,
                           get_key:('-> key) ->
                           get_data:('-> 'b) ->
                           combine:('-> '-> 'b) -> 'r list -> 'b t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                        val clear : 'a t -> unit
                        val copy : 'b t -> 'b t
                        val fold :
                          'b t ->
                          init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                        val iter_keys : 'a t -> f:(key -> unit) -> unit
                        val iter : 'b t -> f:('-> unit) -> unit
                        val iteri :
                          'b t -> f:(key:key -> data:'-> unit) -> unit
                        val iter_vals : 'b t -> f:('-> unit) -> unit
                        val existsi :
                          'b t -> f:(key:key -> data:'-> bool) -> bool
                        val exists : 'b t -> f:('-> bool) -> bool
                        val for_alli :
                          'b t -> f:(key:key -> data:'-> bool) -> bool
                        val for_all : 'b t -> f:('-> bool) -> bool
                        val counti :
                          'b t -> f:(key:key -> data:'-> bool) -> int
                        val count : 'b t -> f:('-> bool) -> int
                        val length : 'a t -> int
                        val is_empty : 'a t -> bool
                        val mem : 'a t -> key -> bool
                        val remove : 'a t -> key -> unit
                        val replace : 'b t -> key:key -> data:'-> unit
                        val set : 'b t -> key:key -> data:'-> unit
                        val add :
                          'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                        val add_or_error :
                          'b t ->
                          key:key -> data:'-> unit Base__.Or_error.t
                        val add_exn : 'b t -> key:key -> data:'-> unit
                        val change :
                          'b t -> key -> f:('b option -> 'b option) -> unit
                        val update :
                          'b t -> key -> f:('b option -> 'b) -> unit
                        val add_multi :
                          'b list t -> key:key -> data:'-> unit
                        val remove_multi : 'a list t -> key -> unit
                        val map : 'b t -> f:('-> 'c) -> 'c t
                        val mapi :
                          'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                        val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                        val filter_mapi :
                          'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                        val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                        val filter : 'b t -> f:('-> bool) -> 'b t
                        val filteri :
                          'b t -> f:(key:key -> data:'-> bool) -> 'b t
                        val partition_map :
                          'b t ->
                          f:('-> [ `Fst of '| `Snd of 'd ]) ->
                          'c t * 'd t
                        val partition_mapi :
                          'b t ->
                          f:(key:key ->
                             data:'-> [ `Fst of '| `Snd of 'd ]) ->
                          'c t * 'd t
                        val partition_tf :
                          'b t -> f:('-> bool) -> 'b t * 'b t
                        val partitioni_tf :
                          'b t ->
                          f:(key:key -> data:'-> bool) -> 'b t * 'b t
                        val find_or_add :
                          'b t -> key -> default:(unit -> 'b) -> 'b
                        val find : 'b t -> key -> 'b option
                        val find_exn : 'b t -> key -> 'b
                        val find_and_call :
                          'b t ->
                          key ->
                          if_found:('-> 'c) ->
                          if_not_found:(key -> 'c) -> 'c
                        val find_and_remove : 'b t -> key -> 'b option
                        val merge :
                          'a t ->
                          'b t ->
                          f:(key:key ->
                             [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                             'c option) ->
                          'c t
                        type 'a merge_into_action = Remove | Set_to of 'a
                        val merge_into :
                          src:'a t ->
                          dst:'b t ->
                          f:(key:key ->
                             '-> 'b option -> 'b merge_into_action) ->
                          unit
                        val keys : 'a t -> key list
                        val data : 'b t -> 'b list
                        val filter_keys_inplace :
                          'a t -> f:(key -> bool) -> unit
                        val filter_inplace : 'b t -> f:('-> bool) -> unit
                        val filteri_inplace :
                          'b t -> f:(key:key -> data:'-> bool) -> unit
                        val map_inplace : 'b t -> f:('-> 'b) -> unit
                        val mapi_inplace :
                          'b t -> f:(key:key -> data:'-> 'b) -> unit
                        val filter_map_inplace :
                          'b t -> f:('-> 'b option) -> unit
                        val filter_mapi_inplace :
                          'b t -> f:(key:key -> data:'-> 'b option) -> unit
                        val replace_all : 'b t -> f:('-> 'b) -> unit
                        val replace_alli :
                          'b t -> f:(key:key -> data:'-> 'b) -> unit
                        val filter_replace_all :
                          'b t -> f:('-> 'b option) -> unit
                        val filter_replace_alli :
                          'b t -> f:(key:key -> data:'-> 'b option) -> unit
                        val equal :
                          'b t -> 'b t -> ('-> '-> bool) -> bool
                        val similar :
                          'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                        val to_alist : 'b t -> (key * 'b) list
                        val validate :
                          name:(key -> string) ->
                          'Base__.Validate.check ->
                          'b t Base__.Validate.check
                        val incr :
                          ?by:int ->
                          ?remove_if_zero:bool -> int t -> key -> unit
                        val decr :
                          ?by:int ->
                          ?remove_if_zero:bool -> int t -> key -> unit
                        module Provide_of_sexp :
                          functor
                            (Key : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> key
                                   end->
                            sig
                              val t_of_sexp :
                                (Sexplib.Sexp.t -> 'v_x__001_) ->
                                Sexplib.Sexp.t -> 'v_x__001_ t
                            end
                        module Provide_bin_io :
                          functor
                            (Key : sig
                                     val bin_t : key Bin_prot.Type_class.t
                                     val bin_read_t :
                                       key Bin_prot.Read.reader
                                     val __bin_read_t__ :
                                       (Core_kernel__.Import.int -> key)
                                       Bin_prot.Read.reader
                                     val bin_reader_t :
                                       key Bin_prot.Type_class.reader
                                     val bin_size_t : key Bin_prot.Size.sizer
                                     val bin_write_t :
                                       key Bin_prot.Write.writer
                                     val bin_writer_t :
                                       key Bin_prot.Type_class.writer
                                     val bin_shape_t : Bin_prot.Shape.t
                                   end->
                            sig
                              val bin_t :
                                'Bin_prot.Type_class.t ->
                                'a t Bin_prot.Type_class.t
                              val bin_read_t :
                                'Bin_prot.Read.reader ->
                                'a t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                'Bin_prot.Read.reader ->
                                (Core_kernel__.Import.int -> 'a t)
                                Bin_prot.Read.reader
                              val bin_reader_t :
                                'Bin_prot.Type_class.reader ->
                                'a t Bin_prot.Type_class.reader
                              val bin_size_t :
                                'Bin_prot.Size.sizer ->
                                'a t Bin_prot.Size.sizer
                              val bin_write_t :
                                'Bin_prot.Write.writer ->
                                'a t Bin_prot.Write.writer
                              val bin_writer_t :
                                'Bin_prot.Type_class.writer ->
                                'a t Bin_prot.Type_class.writer
                              val bin_shape_t :
                                Bin_prot.Shape.t -> Bin_prot.Shape.t
                            end
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__002_) ->
                          Sexplib.Sexp.t -> 'v_x__002_ t
                      end
                    module Hash_set :
                      sig
                        type elt = t
                        type t = elt Core_kernel__.Hash_set.t
                        val sexp_of_t : t -> Sexplib.Sexp.t
                        type 'a t_ = t
                        type 'a elt_ = elt
                        val create :
                          ('a, unit -> t)
                          Core_kernel__.Hash_set_intf.create_options_without_hashable
                        val of_list :
                          ('a, elt list -> t)
                          Core_kernel__.Hash_set_intf.create_options_without_hashable
                        module Provide_of_sexp :
                          functor
                            (X : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> elt
                                 end->
                            sig val t_of_sexp : Sexplib.Sexp.t -> t end
                        module Provide_bin_io :
                          functor
                            (X : sig
                                   val bin_t : elt Bin_prot.Type_class.t
                                   val bin_read_t : elt Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> elt)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     elt Bin_prot.Type_class.reader
                                   val bin_size_t : elt Bin_prot.Size.sizer
                                   val bin_write_t :
                                     elt Bin_prot.Write.writer
                                   val bin_writer_t :
                                     elt Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                            sig
                              val bin_t : t Bin_prot.Type_class.t
                              val bin_read_t : t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                (Core_kernel__.Import.int -> t)
                                Bin_prot.Read.reader
                              val bin_reader_t : t Bin_prot.Type_class.reader
                              val bin_size_t : t Bin_prot.Size.sizer
                              val bin_write_t : t Bin_prot.Write.writer
                              val bin_writer_t : t Bin_prot.Type_class.writer
                              val bin_shape_t : Bin_prot.Shape.t
                            end
                        val t_of_sexp : Sexplib.Sexp.t -> t
                      end
                    module Hash_queue :
                      sig
                        module Key :
                          sig
                            type t = node
                            val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                            val compare : t -> t -> int
                            val hash : t -> int
                          end
                        type 'a t
                        val sexp_of_t :
                          ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                        val length : 'a t -> int
                        val is_empty : 'a t -> bool
                        val iter : 'a t -> f:('-> unit) -> unit
                        val fold :
                          'a t ->
                          init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                        val fold_result :
                          'a t ->
                          init:'accum ->
                          f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                          ('accum, 'e) Base__.Result.t
                        val fold_until :
                          'a t ->
                          init:'accum ->
                          f:('accum ->
                             '->
                             ('accum, 'stop)
                             Base.Container_intf.Continue_or_stop.t) ->
                          ('accum, 'stop)
                          Base.Container_intf.Finished_or_stopped_early.t
                        val exists : 'a t -> f:('-> bool) -> bool
                        val for_all : 'a t -> f:('-> bool) -> bool
                        val count : 'a t -> f:('-> bool) -> int
                        val sum :
                          (module Base__.Commutative_group.S with type t = 'sum) ->
                          'a t -> f:('-> 'sum) -> 'sum
                        val find : 'a t -> f:('-> bool) -> 'a option
                        val find_map :
                          'a t -> f:('-> 'b option) -> 'b option
                        val to_list : 'a t -> 'a list
                        val to_array : 'a t -> 'a array
                        val min_elt :
                          'a t -> cmp:('-> '-> int) -> 'a option
                        val max_elt :
                          'a t -> cmp:('-> '-> int) -> 'a option
                        val invariant : 'a t -> Core_kernel__.Import.unit
                        val create :
                          ?growth_allowed:Core_kernel__.Import.bool ->
                          ?size:Core_kernel__.Import.int ->
                          Core_kernel__.Import.unit -> 'a t
                        val clear : 'a t -> Core_kernel__.Import.unit
                        val mem : 'a t -> node -> Core_kernel__.Import.bool
                        val lookup :
                          'a t -> node -> 'Core_kernel__.Import.option
                        val lookup_exn : 'a t -> node -> 'a
                        val enqueue :
                          'a t ->
                          node -> '-> [ `Key_already_present | `Ok ]
                        val enqueue_exn :
                          'a t -> node -> '-> Core_kernel__.Import.unit
                        val lookup_and_move_to_back :
                          'a t -> node -> 'Core_kernel__.Import.option
                        val lookup_and_move_to_back_exn : 'a t -> node -> 'a
                        val first : 'a t -> 'Core_kernel__.Import.option
                        val first_with_key :
                          'a t -> (node * 'a) Core_kernel__.Import.option
                        val keys : 'a t -> node Core_kernel__.Import.list
                        val dequeue : 'a t -> 'Core_kernel__.Import.option
                        val dequeue_exn : 'a t -> 'a
                        val dequeue_with_key :
                          'a t -> (node * 'a) Core_kernel__.Import.option
                        val dequeue_with_key_exn : 'a t -> node * 'a
                        val dequeue_all :
                          'a t ->
                          f:('-> Core_kernel__.Import.unit) ->
                          Core_kernel__.Import.unit
                        val remove : 'a t -> node -> [ `No_such_key | `Ok ]
                        val remove_exn :
                          'a t -> node -> Core_kernel__.Import.unit
                        val replace :
                          'a t -> node -> '-> [ `No_such_key | `Ok ]
                        val replace_exn :
                          'a t -> node -> '-> Core_kernel__.Import.unit
                        val iteri :
                          'a t ->
                          f:(key:node -> data:'-> Core_kernel__.Import.unit) ->
                          Core_kernel__.Import.unit
                        val foldi :
                          'a t ->
                          init:'->
                          f:('-> key:node -> data:'-> 'b) -> 'b
                      end
                  end
                module Edge :
                  sig
                    type t = edge
                    type node = Node.t
                    type graph = Node.graph
                    type label = EL.t
                    val create : node -> node -> label -> t
                    val label : t -> label
                    val src : t -> node
                    val dst : t -> node
                    val mem : t -> graph -> bool
                    val insert : t -> graph -> graph
                    val update : t -> label -> graph -> graph
                    val remove : t -> graph -> graph
                    val ( >= ) : t -> t -> bool
                    val ( <= ) : t -> t -> bool
                    val ( = ) : t -> t -> bool
                    val ( > ) : t -> t -> bool
                    val ( < ) : t -> t -> bool
                    val ( <> ) : t -> t -> bool
                    val equal : t -> t -> bool
                    val min : t -> t -> t
                    val max : t -> t -> t
                    val ascending : t -> t -> int
                    val descending : t -> t -> int
                    val between : t -> low:t -> high:t -> bool
                    val clamp_exn : t -> min:t -> max:t -> t
                    val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
                    type comparator_witness
                    val comparator :
                      (t, comparator_witness) Base__.Comparator.comparator
                    val validate_lbound :
                      min:t Base__.Maybe_bound.t -> t Base__.Validate.check
                    val validate_ubound :
                      max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                    val validate_bound :
                      min:t Base__.Maybe_bound.t ->
                      max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                    module Replace_polymorphic_compare :
                      sig
                        val ( >= ) : t -> t -> bool
                        val ( <= ) : t -> t -> bool
                        val ( = ) : t -> t -> bool
                        val ( > ) : t -> t -> bool
                        val ( < ) : t -> t -> bool
                        val ( <> ) : t -> t -> bool
                        val equal : t -> t -> bool
                        val compare : t -> t -> int
                        val min : t -> t -> t
                        val max : t -> t -> t
                      end
                    module Map :
                      sig
                        module Key :
                          sig
                            type t = edge
                            val t_of_sexp : Sexplib.Sexp.t -> t
                            val sexp_of_t : t -> Sexplib.Sexp.t
                            type comparator_witness = comparator_witness
                            val comparator :
                              (t, comparator_witness)
                              Core_kernel__.Comparator.comparator
                          end
                        module Tree :
                          sig
                            type 'a t =
                                (edge, 'a, comparator_witness)
                                Core_kernel__.Core_map_intf.Tree.t
                            val empty : 'a t
                            val singleton : edge -> '-> 'a t
                            val of_alist :
                              (edge * 'a) list ->
                              [ `Duplicate_key of edge | `Ok of 'a t ]
                            val of_alist_or_error :
                              (edge * 'a) list -> 'a t Base__.Or_error.t
                            val of_alist_exn : (edge * 'a) list -> 'a t
                            val of_alist_multi :
                              (edge * 'a) list -> 'a list t
                            val of_alist_fold :
                              (edge * 'a) list ->
                              init:'-> f:('-> '-> 'b) -> 'b t
                            val of_alist_reduce :
                              (edge * 'a) list -> f:('-> '-> 'a) -> 'a t
                            val of_sorted_array :
                              (edge * 'a) array -> 'a t Base__.Or_error.t
                            val of_sorted_array_unchecked :
                              (edge * 'a) array -> 'a t
                            val of_increasing_iterator_unchecked :
                              len:int -> f:(int -> edge * 'a) -> 'a t
                            val of_iteri :
                              iteri:(f:(key:edge -> data:'-> unit) -> unit) ->
                              [ `Duplicate_key of edge | `Ok of 'v t ]
                            val of_tree : 'a t -> 'a t
                            val of_hashtbl_exn :
                              (edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                            val gen :
                              edge Core_kernel__.Quickcheck.Generator.t ->
                              'Core_kernel__.Quickcheck.Generator.t ->
                              'a t Core_kernel__.Quickcheck.Generator.t
                            val invariants : 'a t -> bool
                            val is_empty : 'a t -> bool
                            val length : 'a t -> int
                            val add : 'a t -> key:edge -> data:'-> 'a t
                            val add_multi :
                              'a list t -> key:edge -> data:'-> 'a list t
                            val remove_multi : 'a list t -> edge -> 'a list t
                            val change :
                              'a t ->
                              edge -> f:('a option -> 'a option) -> 'a t
                            val update :
                              'a t -> edge -> f:('a option -> 'a) -> 'a t
                            val find : 'a t -> edge -> 'a option
                            val find_exn : 'a t -> edge -> 'a
                            val remove : 'a t -> edge -> 'a t
                            val mem : 'a t -> edge -> bool
                            val iter_keys : 'a t -> f:(edge -> unit) -> unit
                            val iter : 'a t -> f:('-> unit) -> unit
                            val iteri :
                              'a t -> f:(key:edge -> data:'-> unit) -> unit
                            val iter2 :
                              'a t ->
                              'b t ->
                              f:(key:edge ->
                                 data:[ `Both of 'a * 'b
                                      | `Left of 'a
                                      | `Right of 'b ] ->
                                 unit) ->
                              unit
                            val map : 'a t -> f:('-> 'b) -> 'b t
                            val mapi :
                              'a t -> f:(key:edge -> data:'-> 'b) -> 'b t
                            val fold :
                              'a t ->
                              init:'->
                              f:(key:edge -> data:'-> '-> 'b) -> 'b
                            val fold_right :
                              'a t ->
                              init:'->
                              f:(key:edge -> data:'-> '-> 'b) -> 'b
                            val fold2 :
                              'a t ->
                              'b t ->
                              init:'->
                              f:(key:edge ->
                                 data:[ `Both of 'a * 'b
                                      | `Left of 'a
                                      | `Right of 'b ] ->
                                 '-> 'c) ->
                              'c
                            val filter_keys :
                              'a t -> f:(edge -> bool) -> 'a t
                            val filter : 'a t -> f:('-> bool) -> 'a t
                            val filteri :
                              'a t -> f:(key:edge -> data:'-> bool) -> 'a t
                            val filter_map :
                              'a t -> f:('-> 'b option) -> 'b t
                            val filter_mapi :
                              'a t ->
                              f:(key:edge -> data:'-> 'b option) -> 'b t
                            val partition_mapi :
                              'a t ->
                              f:(key:edge ->
                                 data:'-> [ `Fst of '| `Snd of 'c ]) ->
                              'b t * 'c t
                            val partition_map :
                              'a t ->
                              f:('-> [ `Fst of '| `Snd of 'c ]) ->
                              'b t * 'c t
                            val partitioni_tf :
                              'a t ->
                              f:(key:edge -> data:'-> bool) -> 'a t * 'a t
                            val partition_tf :
                              'a t -> f:('-> bool) -> 'a t * 'a t
                            val compare_direct :
                              ('-> '-> int) -> 'a t -> 'a t -> int
                            val equal :
                              ('-> '-> bool) -> 'a t -> 'a t -> bool
                            val keys : 'a t -> edge list
                            val data : 'a t -> 'a list
                            val to_alist :
                              ?key_order:[ `Decreasing | `Increasing ] ->
                              'a t -> (edge * 'a) list
                            val validate :
                              name:(edge -> string) ->
                              'Base__.Validate.check ->
                              'a t Base__.Validate.check
                            val merge :
                              'a t ->
                              'b t ->
                              f:(key:edge ->
                                 [ `Both of 'a * 'b
                                 | `Left of 'a
                                 | `Right of 'b ] -> 'c option) ->
                              'c t
                            val symmetric_diff :
                              'a t ->
                              'a t ->
                              data_equal:('-> '-> bool) ->
                              (edge, 'a)
                              Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                              Base__.Sequence.t
                            val min_elt : 'a t -> (edge * 'a) option
                            val min_elt_exn : 'a t -> edge * 'a
                            val max_elt : 'a t -> (edge * 'a) option
                            val max_elt_exn : 'a t -> edge * 'a
                            val for_all : 'a t -> f:('-> bool) -> bool
                            val for_alli :
                              'a t -> f:(key:edge -> data:'-> bool) -> bool
                            val exists : 'a t -> f:('-> bool) -> bool
                            val existsi :
                              'a t -> f:(key:edge -> data:'-> bool) -> bool
                            val count : 'a t -> f:('-> bool) -> int
                            val counti :
                              'a t -> f:(key:edge -> data:'-> bool) -> int
                            val split :
                              'a t ->
                              edge -> 'a t * (edge * 'a) option * 'a t
                            val append :
                              lower_part:'a t ->
                              upper_part:'a t ->
                              [ `Ok of 'a t | `Overlapping_key_ranges ]
                            val subrange :
                              'a t ->
                              lower_bound:edge Base__.Maybe_bound.t ->
                              upper_bound:edge Base__.Maybe_bound.t -> 'a t
                            val fold_range_inclusive :
                              'a t ->
                              min:edge ->
                              max:edge ->
                              init:'->
                              f:(key:edge -> data:'-> '-> 'b) -> 'b
                            val range_to_alist :
                              'a t ->
                              min:edge -> max:edge -> (edge * 'a) list
                            val closest_key :
                              'a t ->
                              [ `Greater_or_equal_to
                              | `Greater_than
                              | `Less_or_equal_to
                              | `Less_than ] -> edge -> (edge * 'a) option
                            val nth : 'a t -> int -> (edge * 'a) option
                            val nth_exn : 'a t -> int -> edge * 'a
                            val rank : 'a t -> edge -> int option
                            val to_tree : 'a t -> 'a t
                            val to_sequence :
                              ?order:[ `Decreasing_key | `Increasing_key ] ->
                              ?keys_greater_or_equal_to:edge ->
                              ?keys_less_or_equal_to:edge ->
                              'a t -> (edge * 'a) Base__.Sequence.t
                            val obs :
                              edge Core_kernel__.Quickcheck.Observer.t ->
                              'Core_kernel__.Quickcheck.Observer.t ->
                              'v t Core_kernel__.Quickcheck.Observer.t
                            val shrinker :
                              edge Core_kernel__.Quickcheck.Shrinker.t ->
                              'Core_kernel__.Quickcheck.Shrinker.t ->
                              'v t Core_kernel__.Quickcheck.Shrinker.t
                            module Provide_of_sexp :
                              functor
                                (K : sig
                                       val t_of_sexp : Sexplib.Sexp.t -> edge
                                     end->
                                sig
                                  val t_of_sexp :
                                    (Sexplib.Sexp.t -> 'v_x__017_) ->
                                    Sexplib.Sexp.t -> 'v_x__017_ t
                                end
                            val t_of_sexp :
                              (Base__.Sexplib.Sexp.t -> 'a) ->
                              Base__.Sexplib.Sexp.t -> 'a t
                            val sexp_of_t :
                              ('-> Base__.Sexplib.Sexp.t) ->
                              'a t -> Base__.Sexplib.Sexp.t
                          end
                        type 'a t =
                            (edge, 'a, comparator_witness)
                            Core_kernel__.Core_map_intf.Map.t
                        val compare :
                          ('-> '-> Core_kernel__.Import.int) ->
                          'a t -> 'a t -> Core_kernel__.Import.int
                        val empty : 'a t
                        val singleton : edge -> '-> 'a t
                        val of_alist :
                          (edge * 'a) list ->
                          [ `Duplicate_key of edge | `Ok of 'a t ]
                        val of_alist_or_error :
                          (edge * 'a) list -> 'a t Base__.Or_error.t
                        val of_alist_exn : (edge * 'a) list -> 'a t
                        val of_alist_multi : (edge * 'a) list -> 'a list t
                        val of_alist_fold :
                          (edge * 'a) list ->
                          init:'-> f:('-> '-> 'b) -> 'b t
                        val of_alist_reduce :
                          (edge * 'a) list -> f:('-> '-> 'a) -> 'a t
                        val of_sorted_array :
                          (edge * 'a) array -> 'a t Base__.Or_error.t
                        val of_sorted_array_unchecked :
                          (edge * 'a) array -> 'a t
                        val of_increasing_iterator_unchecked :
                          len:int -> f:(int -> edge * 'a) -> 'a t
                        val of_iteri :
                          iteri:(f:(key:edge -> data:'-> unit) -> unit) ->
                          [ `Duplicate_key of edge | `Ok of 'v t ]
                        val of_tree : 'Tree.t -> 'a t
                        val of_hashtbl_exn :
                          (edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                        val gen :
                          edge Core_kernel__.Quickcheck.Generator.t ->
                          'Core_kernel__.Quickcheck.Generator.t ->
                          'a t Core_kernel__.Quickcheck.Generator.t
                        val invariants : 'a t -> bool
                        val is_empty : 'a t -> bool
                        val length : 'a t -> int
                        val add : 'a t -> key:edge -> data:'-> 'a t
                        val add_multi :
                          'a list t -> key:edge -> data:'-> 'a list t
                        val remove_multi : 'a list t -> edge -> 'a list t
                        val change :
                          'a t -> edge -> f:('a option -> 'a option) -> 'a t
                        val update :
                          'a t -> edge -> f:('a option -> 'a) -> 'a t
                        val find : 'a t -> edge -> 'a option
                        val find_exn : 'a t -> edge -> 'a
                        val remove : 'a t -> edge -> 'a t
                        val mem : 'a t -> edge -> bool
                        val iter_keys : 'a t -> f:(edge -> unit) -> unit
                        val iter : 'a t -> f:('-> unit) -> unit
                        val iteri :
                          'a t -> f:(key:edge -> data:'-> unit) -> unit
                        val iter2 :
                          'a t ->
                          'b t ->
                          f:(key:edge ->
                             data:[ `Both of 'a * 'b
                                  | `Left of 'a
                                  | `Right of 'b ] ->
                             unit) ->
                          unit
                        val map : 'a t -> f:('-> 'b) -> 'b t
                        val mapi :
                          'a t -> f:(key:edge -> data:'-> 'b) -> 'b t
                        val fold :
                          'a t ->
                          init:'->
                          f:(key:edge -> data:'-> '-> 'b) -> 'b
                        val fold_right :
                          'a t ->
                          init:'->
                          f:(key:edge -> data:'-> '-> 'b) -> 'b
                        val fold2 :
                          'a t ->
                          'b t ->
                          init:'->
                          f:(key:edge ->
                             data:[ `Both of 'a * 'b
                                  | `Left of 'a
                                  | `Right of 'b ] ->
                             '-> 'c) ->
                          'c
                        val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
                        val filter : 'a t -> f:('-> bool) -> 'a t
                        val filteri :
                          'a t -> f:(key:edge -> data:'-> bool) -> 'a t
                        val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                        val filter_mapi :
                          'a t ->
                          f:(key:edge -> data:'-> 'b option) -> 'b t
                        val partition_mapi :
                          'a t ->
                          f:(key:edge ->
                             data:'-> [ `Fst of '| `Snd of 'c ]) ->
                          'b t * 'c t
                        val partition_map :
                          'a t ->
                          f:('-> [ `Fst of '| `Snd of 'c ]) ->
                          'b t * 'c t
                        val partitioni_tf :
                          'a t ->
                          f:(key:edge -> data:'-> bool) -> 'a t * 'a t
                        val partition_tf :
                          'a t -> f:('-> bool) -> 'a t * 'a t
                        val compare_direct :
                          ('-> '-> int) -> 'a t -> 'a t -> int
                        val equal :
                          ('-> '-> bool) -> 'a t -> 'a t -> bool
                        val keys : 'a t -> edge list
                        val data : 'a t -> 'a list
                        val to_alist :
                          ?key_order:[ `Decreasing | `Increasing ] ->
                          'a t -> (edge * 'a) list
                        val validate :
                          name:(edge -> string) ->
                          'Base__.Validate.check ->
                          'a t Base__.Validate.check
                        val merge :
                          'a t ->
                          'b t ->
                          f:(key:edge ->
                             [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                             'c option) ->
                          'c t
                        val symmetric_diff :
                          'a t ->
                          'a t ->
                          data_equal:('-> '-> bool) ->
                          (edge, 'a)
                          Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                          Base__.Sequence.t
                        val min_elt : 'a t -> (edge * 'a) option
                        val min_elt_exn : 'a t -> edge * 'a
                        val max_elt : 'a t -> (edge * 'a) option
                        val max_elt_exn : 'a t -> edge * 'a
                        val for_all : 'a t -> f:('-> bool) -> bool
                        val for_alli :
                          'a t -> f:(key:edge -> data:'-> bool) -> bool
                        val exists : 'a t -> f:('-> bool) -> bool
                        val existsi :
                          'a t -> f:(key:edge -> data:'-> bool) -> bool
                        val count : 'a t -> f:('-> bool) -> int
                        val counti :
                          'a t -> f:(key:edge -> data:'-> bool) -> int
                        val split :
                          'a t -> edge -> 'a t * (edge * 'a) option * 'a t
                        val append :
                          lower_part:'a t ->
                          upper_part:'a t ->
                          [ `Ok of 'a t | `Overlapping_key_ranges ]
                        val subrange :
                          'a t ->
                          lower_bound:edge Base__.Maybe_bound.t ->
                          upper_bound:edge Base__.Maybe_bound.t -> 'a t
                        val fold_range_inclusive :
                          'a t ->
                          min:edge ->
                          max:edge ->
                          init:'->
                          f:(key:edge -> data:'-> '-> 'b) -> 'b
                        val range_to_alist :
                          'a t -> min:edge -> max:edge -> (edge * 'a) list
                        val closest_key :
                          'a t ->
                          [ `Greater_or_equal_to
                          | `Greater_than
                          | `Less_or_equal_to
                          | `Less_than ] -> edge -> (edge * 'a) option
                        val nth : 'a t -> int -> (edge * 'a) option
                        val nth_exn : 'a t -> int -> edge * 'a
                        val rank : 'a t -> edge -> int option
                        val to_tree : 'a t -> 'Tree.t
                        val to_sequence :
                          ?order:[ `Decreasing_key | `Increasing_key ] ->
                          ?keys_greater_or_equal_to:edge ->
                          ?keys_less_or_equal_to:edge ->
                          'a t -> (edge * 'a) Base__.Sequence.t
                        val obs :
                          edge Core_kernel__.Quickcheck.Observer.t ->
                          'Core_kernel__.Quickcheck.Observer.t ->
                          'v t Core_kernel__.Quickcheck.Observer.t
                        val shrinker :
                          edge Core_kernel__.Quickcheck.Shrinker.t ->
                          'Core_kernel__.Quickcheck.Shrinker.t ->
                          'v t Core_kernel__.Quickcheck.Shrinker.t
                        module Provide_of_sexp :
                          functor
                            (Key : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> edge
                                   end->
                            sig
                              val t_of_sexp :
                                (Sexplib.Sexp.t -> 'v_x__018_) ->
                                Sexplib.Sexp.t -> 'v_x__018_ t
                            end
                        module Provide_bin_io :
                          functor
                            (Key : sig
                                     val bin_t : edge Bin_prot.Type_class.t
                                     val bin_read_t :
                                       edge Bin_prot.Read.reader
                                     val __bin_read_t__ :
                                       (Core_kernel__.Import.int -> edge)
                                       Bin_prot.Read.reader
                                     val bin_reader_t :
                                       edge Bin_prot.Type_class.reader
                                     val bin_size_t :
                                       edge Bin_prot.Size.sizer
                                     val bin_write_t :
                                       edge Bin_prot.Write.writer
                                     val bin_writer_t :
                                       edge Bin_prot.Type_class.writer
                                     val bin_shape_t : Bin_prot.Shape.t
                                   end->
                            sig
                              val bin_shape_t :
                                Bin_prot.Shape.t -> Bin_prot.Shape.t
                              val bin_size_t :
                                ('a, 'a t) Bin_prot.Size.sizer1
                              val bin_write_t :
                                ('a, 'a t) Bin_prot.Write.writer1
                              val bin_read_t :
                                ('a, 'a t) Bin_prot.Read.reader1
                              val __bin_read_t__ :
                                ('a, int -> 'a t) Bin_prot.Read.reader1
                              val bin_writer_t :
                                ('a, 'a t) Bin_prot.Type_class.S1.writer
                              val bin_reader_t :
                                ('a, 'a t) Bin_prot.Type_class.S1.reader
                              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                            end
                        module Provide_hash :
                          functor
                            (Key : sig
                                     val hash_fold_t :
                                       Base__.Hash.state ->
                                       edge -> Base__.Hash.state
                                   end->
                            sig
                              val hash_fold_t :
                                (Ppx_hash_lib.Std.Hash.state ->
                                 '-> Ppx_hash_lib.Std.Hash.state) ->
                                Ppx_hash_lib.Std.Hash.state ->
                                'a t -> Ppx_hash_lib.Std.Hash.state
                            end
                        val t_of_sexp :
                          (Base__.Sexplib.Sexp.t -> 'a) ->
                          Base__.Sexplib.Sexp.t -> 'a t
                        val sexp_of_t :
                          ('-> Base__.Sexplib.Sexp.t) ->
                          'a t -> Base__.Sexplib.Sexp.t
                      end
                    module Set :
                      sig
                        module Elt :
                          sig
                            type t = edge
                            val t_of_sexp : Sexplib.Sexp.t -> t
                            val sexp_of_t : t -> Sexplib.Sexp.t
                            type comparator_witness =
                                Map.Key.comparator_witness
                            val comparator :
                              (t, comparator_witness)
                              Core_kernel__.Comparator.comparator
                          end
                        module Tree :
                          sig
                            type t =
                                (edge, comparator_witness)
                                Core_kernel__.Core_set_intf.Tree.t
                            val compare : t -> t -> Core_kernel__.Import.int
                            val length : t -> int
                            val is_empty : t -> bool
                            val iter : t -> f:(edge -> unit) -> unit
                            val fold :
                              t ->
                              init:'accum ->
                              f:('accum -> edge -> 'accum) -> 'accum
                            val fold_result :
                              t ->
                              init:'accum ->
                              f:('accum ->
                                 edge -> ('accum, 'e) Base__.Result.t) ->
                              ('accum, 'e) Base__.Result.t
                            val exists : t -> f:(edge -> bool) -> bool
                            val for_all : t -> f:(edge -> bool) -> bool
                            val count : t -> f:(edge -> bool) -> int
                            val sum :
                              (module Base__.Commutative_group.S with type t = 'sum) ->
                              t -> f:(edge -> 'sum) -> 'sum
                            val find : t -> f:(edge -> bool) -> edge option
                            val find_map :
                              t -> f:(edge -> 'a option) -> 'a option
                            val to_list : t -> edge list
                            val to_array : t -> edge array
                            val invariants : t -> bool
                            val mem : t -> edge -> bool
                            val add : t -> edge -> t
                            val remove : t -> edge -> t
                            val union : t -> t -> t
                            val inter : t -> t -> t
                            val diff : t -> t -> t
                            val symmetric_diff :
                              t ->
                              t ->
                              (edge, edge) Base__.Either.t Base__.Sequence.t
                            val compare_direct : t -> t -> int
                            val equal : t -> t -> bool
                            val is_subset : t -> of_:t -> bool
                            val subset : t -> t -> bool
                            val fold_until :
                              t ->
                              init:'->
                              f:('->
                                 edge ->
                                 ('b, 'stop)
                                 Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                              ('b, 'stop)
                              Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                            val fold_right :
                              t -> init:'-> f:(edge -> '-> 'b) -> 'b
                            val iter2 :
                              t ->
                              t ->
                              f:([ `Both of edge * edge
                                 | `Left of edge
                                 | `Right of edge ] -> unit) ->
                              unit
                            val filter : t -> f:(edge -> bool) -> t
                            val partition_tf : t -> f:(edge -> bool) -> t * t
                            val elements : t -> edge list
                            val min_elt : t -> edge option
                            val min_elt_exn : t -> edge
                            val max_elt : t -> edge option
                            val max_elt_exn : t -> edge
                            val choose : t -> edge option
                            val choose_exn : t -> edge
                            val split : t -> edge -> t * edge option * t
                            val group_by :
                              t -> equiv:(edge -> edge -> bool) -> t list
                            val find_exn : t -> f:(edge -> bool) -> edge
                            val find_index : t -> int -> edge option
                            val nth : t -> int -> edge option
                            val remove_index : t -> int -> t
                            val to_tree : t -> t
                            val to_sequence :
                              ?order:[ `Decreasing | `Increasing ] ->
                              ?greater_or_equal_to:edge ->
                              ?less_or_equal_to:edge ->
                              t -> edge Base__.Sequence.t
                            val merge_to_sequence :
                              ?order:[ `Decreasing | `Increasing ] ->
                              ?greater_or_equal_to:edge ->
                              ?less_or_equal_to:edge ->
                              t ->
                              t ->
                              (edge, edge)
                              Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                              Base__.Sequence.t
                            val to_map :
                              t ->
                              f:(edge -> 'data) ->
                              (edge, 'data, comparator_witness)
                              Core_kernel__.Core_set_intf.Map.t
                            val obs :
                              edge Core_kernel__.Quickcheck.Observer.t ->
                              t Core_kernel__.Quickcheck.Observer.t
                            val shrinker :
                              edge Core_kernel__.Quickcheck.Shrinker.t ->
                              t Core_kernel__.Quickcheck.Shrinker.t
                            val empty : t
                            val singleton : edge -> t
                            val union_list : t list -> t
                            val of_list : edge list -> t
                            val of_array : edge array -> t
                            val of_sorted_array :
                              edge array -> t Base__.Or_error.t
                            val of_sorted_array_unchecked : edge array -> t
                            val of_increasing_iterator_unchecked :
                              len:int -> f:(int -> edge) -> t
                            val stable_dedup_list : edge list -> edge list
                            val map :
                              ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                              f:('-> edge) -> t
                            val filter_map :
                              ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                              f:('-> edge option) -> t
                            val of_tree : t -> t
                            val of_hash_set :
                              edge Core_kernel__.Hash_set.t -> t
                            val of_hashtbl_keys :
                              (edge, 'a) Core_kernel__.Core_hashtbl.t -> t
                            val of_map_keys :
                              (edge, 'a, comparator_witness)
                              Core_kernel__.Core_set_intf.Map.t -> t
                            val gen :
                              edge Core_kernel__.Quickcheck.Generator.t ->
                              t Core_kernel__.Quickcheck.Generator.t
                            module Provide_of_sexp :
                              functor
                                (Elt : sig
                                         val t_of_sexp :
                                           Sexplib.Sexp.t -> edge
                                       end->
                                sig val t_of_sexp : Sexplib.Sexp.t -> t end
                            val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                            val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                          end
                        type t = (edge, comparator_witness) Base.Set.t
                        val compare : t -> t -> Core_kernel__.Import.int
                        val length : t -> int
                        val is_empty : t -> bool
                        val iter : t -> f:(edge -> unit) -> unit
                        val fold :
                          t ->
                          init:'accum ->
                          f:('accum -> edge -> 'accum) -> 'accum
                        val fold_result :
                          t ->
                          init:'accum ->
                          f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
                          ('accum, 'e) Base__.Result.t
                        val exists : t -> f:(edge -> bool) -> bool
                        val for_all : t -> f:(edge -> bool) -> bool
                        val count : t -> f:(edge -> bool) -> int
                        val sum :
                          (module Base__.Commutative_group.S with type t = 'sum) ->
                          t -> f:(edge -> 'sum) -> 'sum
                        val find : t -> f:(edge -> bool) -> edge option
                        val find_map :
                          t -> f:(edge -> 'a option) -> 'a option
                        val to_list : t -> edge list
                        val to_array : t -> edge array
                        val invariants : t -> bool
                        val mem : t -> edge -> bool
                        val add : t -> edge -> t
                        val remove : t -> edge -> t
                        val union : t -> t -> t
                        val inter : t -> t -> t
                        val diff : t -> t -> t
                        val symmetric_diff :
                          t ->
                          t -> (edge, edge) Base__.Either.t Base__.Sequence.t
                        val compare_direct : t -> t -> int
                        val equal : t -> t -> bool
                        val is_subset : t -> of_:t -> bool
                        val subset : t -> t -> bool
                        val fold_until :
                          t ->
                          init:'->
                          f:('->
                             edge ->
                             ('b, 'stop)
                             Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                          ('b, 'stop)
                          Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                        val fold_right :
                          t -> init:'-> f:(edge -> '-> 'b) -> 'b
                        val iter2 :
                          t ->
                          t ->
                          f:([ `Both of edge * edge
                             | `Left of edge
                             | `Right of edge ] -> unit) ->
                          unit
                        val filter : t -> f:(edge -> bool) -> t
                        val partition_tf : t -> f:(edge -> bool) -> t * t
                        val elements : t -> edge list
                        val min_elt : t -> edge option
                        val min_elt_exn : t -> edge
                        val max_elt : t -> edge option
                        val max_elt_exn : t -> edge
                        val choose : t -> edge option
                        val choose_exn : t -> edge
                        val split : t -> edge -> t * edge option * t
                        val group_by :
                          t -> equiv:(edge -> edge -> bool) -> t list
                        val find_exn : t -> f:(edge -> bool) -> edge
                        val find_index : t -> int -> edge option
                        val nth : t -> int -> edge option
                        val remove_index : t -> int -> t
                        val to_tree : t -> Tree.t
                        val to_sequence :
                          ?order:[ `Decreasing | `Increasing ] ->
                          ?greater_or_equal_to:edge ->
                          ?less_or_equal_to:edge ->
                          t -> edge Base__.Sequence.t
                        val merge_to_sequence :
                          ?order:[ `Decreasing | `Increasing ] ->
                          ?greater_or_equal_to:edge ->
                          ?less_or_equal_to:edge ->
                          t ->
                          t ->
                          (edge, edge)
                          Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                          Base__.Sequence.t
                        val to_map :
                          t ->
                          f:(edge -> 'data) ->
                          (edge, 'data, comparator_witness)
                          Core_kernel__.Core_set_intf.Map.t
                        val obs :
                          edge Core_kernel__.Quickcheck.Observer.t ->
                          t Core_kernel__.Quickcheck.Observer.t
                        val shrinker :
                          edge Core_kernel__.Quickcheck.Shrinker.t ->
                          t Core_kernel__.Quickcheck.Shrinker.t
                        val empty : t
                        val singleton : edge -> t
                        val union_list : t list -> t
                        val of_list : edge list -> t
                        val of_array : edge array -> t
                        val of_sorted_array :
                          edge array -> t Base__.Or_error.t
                        val of_sorted_array_unchecked : edge array -> t
                        val of_increasing_iterator_unchecked :
                          len:int -> f:(int -> edge) -> t
                        val stable_dedup_list : edge list -> edge list
                        val map : ('a, 'b) Base.Set.t -> f:('-> edge) -> t
                        val filter_map :
                          ('a, 'b) Base.Set.t -> f:('-> edge option) -> t
                        val of_tree : Tree.t -> t
                        val of_hash_set : edge Core_kernel__.Hash_set.t -> t
                        val of_hashtbl_keys :
                          (edge, 'a) Core_kernel__.Core_hashtbl.t -> t
                        val of_map_keys :
                          (edge, 'a, comparator_witness)
                          Core_kernel__.Core_set_intf.Map.t -> t
                        val gen :
                          edge Core_kernel__.Quickcheck.Generator.t ->
                          t Core_kernel__.Quickcheck.Generator.t
                        module Provide_of_sexp :
                          functor
                            (Elt : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> edge
                                   end->
                            sig val t_of_sexp : Sexplib.Sexp.t -> t end
                        module Provide_bin_io :
                          functor
                            (Elt : sig
                                     val bin_t : edge Bin_prot.Type_class.t
                                     val bin_read_t :
                                       edge Bin_prot.Read.reader
                                     val __bin_read_t__ :
                                       (Core_kernel__.Import.int -> edge)
                                       Bin_prot.Read.reader
                                     val bin_reader_t :
                                       edge Bin_prot.Type_class.reader
                                     val bin_size_t :
                                       edge Bin_prot.Size.sizer
                                     val bin_write_t :
                                       edge Bin_prot.Write.writer
                                     val bin_writer_t :
                                       edge Bin_prot.Type_class.writer
                                     val bin_shape_t : Bin_prot.Shape.t
                                   end->
                            sig
                              val bin_size_t : t Bin_prot.Size.sizer
                              val bin_write_t : t Bin_prot.Write.writer
                              val bin_read_t : t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                (int -> t) Bin_prot.Read.reader
                              val bin_shape_t : Bin_prot.Shape.t
                              val bin_writer_t : t Bin_prot.Type_class.writer
                              val bin_reader_t : t Bin_prot.Type_class.reader
                              val bin_t : t Bin_prot.Type_class.t
                            end
                        module Provide_hash :
                          functor
                            (Elt : sig
                                     val hash_fold_t :
                                       Base__.Hash.state ->
                                       edge -> Base__.Hash.state
                                   end->
                            sig
                              val hash_fold_t :
                                Ppx_hash_lib.Std.Hash.state ->
                                t -> Ppx_hash_lib.Std.Hash.state
                              val hash :
                                t -> Ppx_hash_lib.Std.Hash.hash_value
                            end
                        val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                        val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                      end
                    val hash : t -> Core_kernel__.Import.int
                    val compare : t -> t -> Core_kernel__.Import.int
                    val hashable :
                      t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
                    module Table :
                      sig
                        type key = t
                        type ('a, 'b) hashtbl = ('a, 'b) Node.Table.hashtbl
                        type 'b t = (key, 'b) hashtbl
                        val sexp_of_t :
                          ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                        type ('a, 'b) t_ = 'b t
                        type 'a key_ = key
                        val hashable :
                          key Core_kernel__.Core_hashtbl_intf.Hashable.t
                        val invariant :
                          'Base__.Invariant_intf.inv ->
                          'a t Base__.Invariant_intf.inv
                        val create :
                          (key, 'b, unit -> 'b t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist :
                          (key, 'b,
                           (key * 'b) list ->
                           [ `Duplicate_key of key | `Ok of 'b t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_report_all_dups :
                          (key, 'b,
                           (key * 'b) list ->
                           [ `Duplicate_keys of key list | `Ok of 'b t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_or_error :
                          (key, 'b,
                           (key * 'b) list -> 'b t Base__.Or_error.t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_exn :
                          (key, 'b, (key * 'b) list -> 'b t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_multi :
                          (key, 'b list, (key * 'b) list -> 'b list t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_mapped :
                          (key, 'b,
                           get_key:('-> key) ->
                           get_data:('-> 'b) ->
                           'r list ->
                           [ `Duplicate_keys of key list | `Ok of 'b t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_with_key :
                          (key, 'r,
                           get_key:('-> key) ->
                           'r list ->
                           [ `Duplicate_keys of key list | `Ok of 'r t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_with_key_or_error :
                          (key, 'r,
                           get_key:('-> key) ->
                           'r list -> 'r t Base__.Or_error.t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_with_key_exn :
                          (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val group :
                          (key, 'b,
                           get_key:('-> key) ->
                           get_data:('-> 'b) ->
                           combine:('-> '-> 'b) -> 'r list -> 'b t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                        val clear : 'a t -> unit
                        val copy : 'b t -> 'b t
                        val fold :
                          'b t ->
                          init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                        val iter_keys : 'a t -> f:(key -> unit) -> unit
                        val iter : 'b t -> f:('-> unit) -> unit
                        val iteri :
                          'b t -> f:(key:key -> data:'-> unit) -> unit
                        val iter_vals : 'b t -> f:('-> unit) -> unit
                        val existsi :
                          'b t -> f:(key:key -> data:'-> bool) -> bool
                        val exists : 'b t -> f:('-> bool) -> bool
                        val for_alli :
                          'b t -> f:(key:key -> data:'-> bool) -> bool
                        val for_all : 'b t -> f:('-> bool) -> bool
                        val counti :
                          'b t -> f:(key:key -> data:'-> bool) -> int
                        val count : 'b t -> f:('-> bool) -> int
                        val length : 'a t -> int
                        val is_empty : 'a t -> bool
                        val mem : 'a t -> key -> bool
                        val remove : 'a t -> key -> unit
                        val replace : 'b t -> key:key -> data:'-> unit
                        val set : 'b t -> key:key -> data:'-> unit
                        val add :
                          'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                        val add_or_error :
                          'b t ->
                          key:key -> data:'-> unit Base__.Or_error.t
                        val add_exn : 'b t -> key:key -> data:'-> unit
                        val change :
                          'b t -> key -> f:('b option -> 'b option) -> unit
                        val update :
                          'b t -> key -> f:('b option -> 'b) -> unit
                        val add_multi :
                          'b list t -> key:key -> data:'-> unit
                        val remove_multi : 'a list t -> key -> unit
                        val map : 'b t -> f:('-> 'c) -> 'c t
                        val mapi :
                          'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                        val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                        val filter_mapi :
                          'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                        val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                        val filter : 'b t -> f:('-> bool) -> 'b t
                        val filteri :
                          'b t -> f:(key:key -> data:'-> bool) -> 'b t
                        val partition_map :
                          'b t ->
                          f:('-> [ `Fst of '| `Snd of 'd ]) ->
                          'c t * 'd t
                        val partition_mapi :
                          'b t ->
                          f:(key:key ->
                             data:'-> [ `Fst of '| `Snd of 'd ]) ->
                          'c t * 'd t
                        val partition_tf :
                          'b t -> f:('-> bool) -> 'b t * 'b t
                        val partitioni_tf :
                          'b t ->
                          f:(key:key -> data:'-> bool) -> 'b t * 'b t
                        val find_or_add :
                          'b t -> key -> default:(unit -> 'b) -> 'b
                        val find : 'b t -> key -> 'b option
                        val find_exn : 'b t -> key -> 'b
                        val find_and_call :
                          'b t ->
                          key ->
                          if_found:('-> 'c) ->
                          if_not_found:(key -> 'c) -> 'c
                        val find_and_remove : 'b t -> key -> 'b option
                        val merge :
                          'a t ->
                          'b t ->
                          f:(key:key ->
                             [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                             'c option) ->
                          'c t
                        type 'a merge_into_action = Remove | Set_to of 'a
                        val merge_into :
                          src:'a t ->
                          dst:'b t ->
                          f:(key:key ->
                             '-> 'b option -> 'b merge_into_action) ->
                          unit
                        val keys : 'a t -> key list
                        val data : 'b t -> 'b list
                        val filter_keys_inplace :
                          'a t -> f:(key -> bool) -> unit
                        val filter_inplace : 'b t -> f:('-> bool) -> unit
                        val filteri_inplace :
                          'b t -> f:(key:key -> data:'-> bool) -> unit
                        val map_inplace : 'b t -> f:('-> 'b) -> unit
                        val mapi_inplace :
                          'b t -> f:(key:key -> data:'-> 'b) -> unit
                        val filter_map_inplace :
                          'b t -> f:('-> 'b option) -> unit
                        val filter_mapi_inplace :
                          'b t -> f:(key:key -> data:'-> 'b option) -> unit
                        val replace_all : 'b t -> f:('-> 'b) -> unit
                        val replace_alli :
                          'b t -> f:(key:key -> data:'-> 'b) -> unit
                        val filter_replace_all :
                          'b t -> f:('-> 'b option) -> unit
                        val filter_replace_alli :
                          'b t -> f:(key:key -> data:'-> 'b option) -> unit
                        val equal :
                          'b t -> 'b t -> ('-> '-> bool) -> bool
                        val similar :
                          'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                        val to_alist : 'b t -> (key * 'b) list
                        val validate :
                          name:(key -> string) ->
                          'Base__.Validate.check ->
                          'b t Base__.Validate.check
                        val incr :
                          ?by:int ->
                          ?remove_if_zero:bool -> int t -> key -> unit
                        val decr :
                          ?by:int ->
                          ?remove_if_zero:bool -> int t -> key -> unit
                        module Provide_of_sexp :
                          functor
                            (Key : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> key
                                   end->
                            sig
                              val t_of_sexp :
                                (Sexplib.Sexp.t -> 'v_x__001_) ->
                                Sexplib.Sexp.t -> 'v_x__001_ t
                            end
                        module Provide_bin_io :
                          functor
                            (Key : sig
                                     val bin_t : key Bin_prot.Type_class.t
                                     val bin_read_t :
                                       key Bin_prot.Read.reader
                                     val __bin_read_t__ :
                                       (Core_kernel__.Import.int -> key)
                                       Bin_prot.Read.reader
                                     val bin_reader_t :
                                       key Bin_prot.Type_class.reader
                                     val bin_size_t : key Bin_prot.Size.sizer
                                     val bin_write_t :
                                       key Bin_prot.Write.writer
                                     val bin_writer_t :
                                       key Bin_prot.Type_class.writer
                                     val bin_shape_t : Bin_prot.Shape.t
                                   end->
                            sig
                              val bin_t :
                                'Bin_prot.Type_class.t ->
                                'a t Bin_prot.Type_class.t
                              val bin_read_t :
                                'Bin_prot.Read.reader ->
                                'a t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                'Bin_prot.Read.reader ->
                                (Core_kernel__.Import.int -> 'a t)
                                Bin_prot.Read.reader
                              val bin_reader_t :
                                'Bin_prot.Type_class.reader ->
                                'a t Bin_prot.Type_class.reader
                              val bin_size_t :
                                'Bin_prot.Size.sizer ->
                                'a t Bin_prot.Size.sizer
                              val bin_write_t :
                                'Bin_prot.Write.writer ->
                                'a t Bin_prot.Write.writer
                              val bin_writer_t :
                                'Bin_prot.Type_class.writer ->
                                'a t Bin_prot.Type_class.writer
                              val bin_shape_t :
                                Bin_prot.Shape.t -> Bin_prot.Shape.t
                            end
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__002_) ->
                          Sexplib.Sexp.t -> 'v_x__002_ t
                      end
                    module Hash_set :
                      sig
                        type elt = t
                        type t = elt Core_kernel__.Hash_set.t
                        val sexp_of_t : t -> Sexplib.Sexp.t
                        type 'a t_ = t
                        type 'a elt_ = elt
                        val create :
                          ('a, unit -> t)
                          Core_kernel__.Hash_set_intf.create_options_without_hashable
                        val of_list :
                          ('a, elt list -> t)
                          Core_kernel__.Hash_set_intf.create_options_without_hashable
                        module Provide_of_sexp :
                          functor
                            (X : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> elt
                                 end->
                            sig val t_of_sexp : Sexplib.Sexp.t -> t end
                        module Provide_bin_io :
                          functor
                            (X : sig
                                   val bin_t : elt Bin_prot.Type_class.t
                                   val bin_read_t : elt Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> elt)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     elt Bin_prot.Type_class.reader
                                   val bin_size_t : elt Bin_prot.Size.sizer
                                   val bin_write_t :
                                     elt Bin_prot.Write.writer
                                   val bin_writer_t :
                                     elt Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                            sig
                              val bin_t : t Bin_prot.Type_class.t
                              val bin_read_t : t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                (Core_kernel__.Import.int -> t)
                                Bin_prot.Read.reader
                              val bin_reader_t : t Bin_prot.Type_class.reader
                              val bin_size_t : t Bin_prot.Size.sizer
                              val bin_write_t : t Bin_prot.Write.writer
                              val bin_writer_t : t Bin_prot.Type_class.writer
                              val bin_shape_t : Bin_prot.Shape.t
                            end
                        val t_of_sexp : Sexplib.Sexp.t -> t
                      end
                    module Hash_queue :
                      sig
                        module Key :
                          sig
                            type t = edge
                            val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                            val compare : t -> t -> int
                            val hash : t -> int
                          end
                        type 'a t
                        val sexp_of_t :
                          ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                        val length : 'a t -> int
                        val is_empty : 'a t -> bool
                        val iter : 'a t -> f:('-> unit) -> unit
                        val fold :
                          'a t ->
                          init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                        val fold_result :
                          'a t ->
                          init:'accum ->
                          f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                          ('accum, 'e) Base__.Result.t
                        val fold_until :
                          'a t ->
                          init:'accum ->
                          f:('accum ->
                             '->
                             ('accum, 'stop)
                             Base.Container_intf.Continue_or_stop.t) ->
                          ('accum, 'stop)
                          Base.Container_intf.Finished_or_stopped_early.t
                        val exists : 'a t -> f:('-> bool) -> bool
                        val for_all : 'a t -> f:('-> bool) -> bool
                        val count : 'a t -> f:('-> bool) -> int
                        val sum :
                          (module Base__.Commutative_group.S with type t = 'sum) ->
                          'a t -> f:('-> 'sum) -> 'sum
                        val find : 'a t -> f:('-> bool) -> 'a option
                        val find_map :
                          'a t -> f:('-> 'b option) -> 'b option
                        val to_list : 'a t -> 'a list
                        val to_array : 'a t -> 'a array
                        val min_elt :
                          'a t -> cmp:('-> '-> int) -> 'a option
                        val max_elt :
                          'a t -> cmp:('-> '-> int) -> 'a option
                        val invariant : 'a t -> Core_kernel__.Import.unit
                        val create :
                          ?growth_allowed:Core_kernel__.Import.bool ->
                          ?size:Core_kernel__.Import.int ->
                          Core_kernel__.Import.unit -> 'a t
                        val clear : 'a t -> Core_kernel__.Import.unit
                        val mem : 'a t -> edge -> Core_kernel__.Import.bool
                        val lookup :
                          'a t -> edge -> 'Core_kernel__.Import.option
                        val lookup_exn : 'a t -> edge -> 'a
                        val enqueue :
                          'a t ->
                          edge -> '-> [ `Key_already_present | `Ok ]
                        val enqueue_exn :
                          'a t -> edge -> '-> Core_kernel__.Import.unit
                        val lookup_and_move_to_back :
                          'a t -> edge -> 'Core_kernel__.Import.option
                        val lookup_and_move_to_back_exn : 'a t -> edge -> 'a
                        val first : 'a t -> 'Core_kernel__.Import.option
                        val first_with_key :
                          'a t -> (edge * 'a) Core_kernel__.Import.option
                        val keys : 'a t -> edge Core_kernel__.Import.list
                        val dequeue : 'a t -> 'Core_kernel__.Import.option
                        val dequeue_exn : 'a t -> 'a
                        val dequeue_with_key :
                          'a t -> (edge * 'a) Core_kernel__.Import.option
                        val dequeue_with_key_exn : 'a t -> edge * 'a
                        val dequeue_all :
                          'a t ->
                          f:('-> Core_kernel__.Import.unit) ->
                          Core_kernel__.Import.unit
                        val remove : 'a t -> edge -> [ `No_such_key | `Ok ]
                        val remove_exn :
                          'a t -> edge -> Core_kernel__.Import.unit
                        val replace :
                          'a t -> edge -> '-> [ `No_such_key | `Ok ]
                        val replace_exn :
                          'a t -> edge -> '-> Core_kernel__.Import.unit
                        val iteri :
                          'a t ->
                          f:(key:edge -> data:'-> Core_kernel__.Import.unit) ->
                          Core_kernel__.Import.unit
                        val foldi :
                          'a t ->
                          init:'->
                          f:('-> key:edge -> data:'-> 'b) -> 'b
                      end
                  end
                val empty : t
                val nodes : t -> node Regular.Std.seq
                val edges : t -> edge Regular.Std.seq
                val is_directed : bool
                val number_of_edges : t -> int
                val number_of_nodes : t -> int
                val ( >= ) : t -> t -> bool
                val ( <= ) : t -> t -> bool
                val ( = ) : t -> t -> bool
                val ( > ) : t -> t -> bool
                val ( < ) : t -> t -> bool
                val ( <> ) : t -> t -> bool
                val equal : t -> t -> bool
                val min : t -> t -> t
                val max : t -> t -> t
                val ascending : t -> t -> int
                val descending : t -> t -> int
                val between : t -> low:t -> high:t -> bool
                val clamp_exn : t -> min:t -> max:t -> t
                val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
                type comparator_witness
                val comparator :
                  (t, comparator_witness) Base__.Comparator.comparator
                val validate_lbound :
                  min:t Base__.Maybe_bound.t -> t Base__.Validate.check
                val validate_ubound :
                  max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                val validate_bound :
                  min:t Base__.Maybe_bound.t ->
                  max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                module Replace_polymorphic_compare :
                  sig
                    val ( >= ) : t -> t -> bool
                    val ( <= ) : t -> t -> bool
                    val ( = ) : t -> t -> bool
                    val ( > ) : t -> t -> bool
                    val ( < ) : t -> t -> bool
                    val ( <> ) : t -> t -> bool
                    val equal : t -> t -> bool
                    val compare : t -> t -> int
                    val min : t -> t -> t
                    val max : t -> t -> t
                  end
                module Map :
                  sig
                    module Key :
                      sig
                        type t = Edge.graph
                        val t_of_sexp : Sexplib.Sexp.t -> t
                        val sexp_of_t : t -> Sexplib.Sexp.t
                        type comparator_witness = comparator_witness
                        val comparator :
                          (t, comparator_witness)
                          Core_kernel__.Comparator.comparator
                      end
                    module Tree :
                      sig
                        type 'a t =
                            (Key.t, 'a, comparator_witness)
                            Core_kernel__.Core_map_intf.Tree.t
                        val empty : 'a t
                        val singleton : Key.t -> '-> 'a t
                        val of_alist :
                          (Key.t * 'a) list ->
                          [ `Duplicate_key of Key.t | `Ok of 'a t ]
                        val of_alist_or_error :
                          (Key.t * 'a) list -> 'a t Base__.Or_error.t
                        val of_alist_exn : (Key.t * 'a) list -> 'a t
                        val of_alist_multi : (Key.t * 'a) list -> 'a list t
                        val of_alist_fold :
                          (Key.t * 'a) list ->
                          init:'-> f:('-> '-> 'b) -> 'b t
                        val of_alist_reduce :
                          (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                        val of_sorted_array :
                          (Key.t * 'a) array -> 'a t Base__.Or_error.t
                        val of_sorted_array_unchecked :
                          (Key.t * 'a) array -> 'a t
                        val of_increasing_iterator_unchecked :
                          len:int -> f:(int -> Key.t * 'a) -> 'a t
                        val of_iteri :
                          iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                          [ `Duplicate_key of Key.t | `Ok of 'v t ]
                        val of_tree : 'a t -> 'a t
                        val of_hashtbl_exn :
                          (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                        val gen :
                          Key.t Core_kernel__.Quickcheck.Generator.t ->
                          'Core_kernel__.Quickcheck.Generator.t ->
                          'a t Core_kernel__.Quickcheck.Generator.t
                        val invariants : 'a t -> bool
                        val is_empty : 'a t -> bool
                        val length : 'a t -> int
                        val add : 'a t -> key:Key.t -> data:'-> 'a t
                        val add_multi :
                          'a list t -> key:Key.t -> data:'-> 'a list t
                        val remove_multi : 'a list t -> Key.t -> 'a list t
                        val change :
                          'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                        val update :
                          'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                        val find : 'a t -> Key.t -> 'a option
                        val find_exn : 'a t -> Key.t -> 'a
                        val remove : 'a t -> Key.t -> 'a t
                        val mem : 'a t -> Key.t -> bool
                        val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                        val iter : 'a t -> f:('-> unit) -> unit
                        val iteri :
                          'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                        val iter2 :
                          'a t ->
                          'b t ->
                          f:(key:Key.t ->
                             data:[ `Both of 'a * 'b
                                  | `Left of 'a
                                  | `Right of 'b ] ->
                             unit) ->
                          unit
                        val map : 'a t -> f:('-> 'b) -> 'b t
                        val mapi :
                          'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                        val fold :
                          'a t ->
                          init:'->
                          f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                        val fold_right :
                          'a t ->
                          init:'->
                          f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                        val fold2 :
                          'a t ->
                          'b t ->
                          init:'->
                          f:(key:Key.t ->
                             data:[ `Both of 'a * 'b
                                  | `Left of 'a
                                  | `Right of 'b ] ->
                             '-> 'c) ->
                          'c
                        val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                        val filter : 'a t -> f:('-> bool) -> 'a t
                        val filteri :
                          'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                        val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                        val filter_mapi :
                          'a t ->
                          f:(key:Key.t -> data:'-> 'b option) -> 'b t
                        val partition_mapi :
                          'a t ->
                          f:(key:Key.t ->
                             data:'-> [ `Fst of '| `Snd of 'c ]) ->
                          'b t * 'c t
                        val partition_map :
                          'a t ->
                          f:('-> [ `Fst of '| `Snd of 'c ]) ->
                          'b t * 'c t
                        val partitioni_tf :
                          'a t ->
                          f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                        val partition_tf :
                          'a t -> f:('-> bool) -> 'a t * 'a t
                        val compare_direct :
                          ('-> '-> int) -> 'a t -> 'a t -> int
                        val equal :
                          ('-> '-> bool) -> 'a t -> 'a t -> bool
                        val keys : 'a t -> Key.t list
                        val data : 'a t -> 'a list
                        val to_alist :
                          ?key_order:[ `Decreasing | `Increasing ] ->
                          'a t -> (Key.t * 'a) list
                        val validate :
                          name:(Key.t -> string) ->
                          'Base__.Validate.check ->
                          'a t Base__.Validate.check
                        val merge :
                          'a t ->
                          'b t ->
                          f:(key:Key.t ->
                             [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                             'c option) ->
                          'c t
                        val symmetric_diff :
                          'a t ->
                          'a t ->
                          data_equal:('-> '-> bool) ->
                          (Key.t, 'a)
                          Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                          Base__.Sequence.t
                        val min_elt : 'a t -> (Key.t * 'a) option
                        val min_elt_exn : 'a t -> Key.t * 'a
                        val max_elt : 'a t -> (Key.t * 'a) option
                        val max_elt_exn : 'a t -> Key.t * 'a
                        val for_all : 'a t -> f:('-> bool) -> bool
                        val for_alli :
                          'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                        val exists : 'a t -> f:('-> bool) -> bool
                        val existsi :
                          'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                        val count : 'a t -> f:('-> bool) -> int
                        val counti :
                          'a t -> f:(key:Key.t -> data:'-> bool) -> int
                        val split :
                          'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                        val append :
                          lower_part:'a t ->
                          upper_part:'a t ->
                          [ `Ok of 'a t | `Overlapping_key_ranges ]
                        val subrange :
                          'a t ->
                          lower_bound:Key.t Base__.Maybe_bound.t ->
                          upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                        val fold_range_inclusive :
                          'a t ->
                          min:Key.t ->
                          max:Key.t ->
                          init:'->
                          f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                        val range_to_alist :
                          'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                        val closest_key :
                          'a t ->
                          [ `Greater_or_equal_to
                          | `Greater_than
                          | `Less_or_equal_to
                          | `Less_than ] -> Key.t -> (Key.t * 'a) option
                        val nth : 'a t -> int -> (Key.t * 'a) option
                        val nth_exn : 'a t -> int -> Key.t * 'a
                        val rank : 'a t -> Key.t -> int option
                        val to_tree : 'a t -> 'a t
                        val to_sequence :
                          ?order:[ `Decreasing_key | `Increasing_key ] ->
                          ?keys_greater_or_equal_to:Key.t ->
                          ?keys_less_or_equal_to:Key.t ->
                          'a t -> (Key.t * 'a) Base__.Sequence.t
                        val obs :
                          Key.t Core_kernel__.Quickcheck.Observer.t ->
                          'Core_kernel__.Quickcheck.Observer.t ->
                          'v t Core_kernel__.Quickcheck.Observer.t
                        val shrinker :
                          Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                          'Core_kernel__.Quickcheck.Shrinker.t ->
                          'v t Core_kernel__.Quickcheck.Shrinker.t
                        module Provide_of_sexp :
                          functor
                            (K : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> Key.t
                                 end->
                            sig
                              val t_of_sexp :
                                (Sexplib.Sexp.t -> 'v_x__017_) ->
                                Sexplib.Sexp.t -> 'v_x__017_ t
                            end
                        val t_of_sexp :
                          (Base__.Sexplib.Sexp.t -> 'a) ->
                          Base__.Sexplib.Sexp.t -> 'a t
                        val sexp_of_t :
                          ('-> Base__.Sexplib.Sexp.t) ->
                          'a t -> Base__.Sexplib.Sexp.t
                      end
                    type 'a t =
                        (Key.t, 'a, comparator_witness)
                        Core_kernel__.Core_map_intf.Map.t
                    val compare :
                      ('-> '-> Core_kernel__.Import.int) ->
                      'a t -> 'a t -> Core_kernel__.Import.int
                    val empty : 'a t
                    val singleton : Key.t -> '-> 'a t
                    val of_alist :
                      (Key.t * 'a) list ->
                      [ `Duplicate_key of Key.t | `Ok of 'a t ]
                    val of_alist_or_error :
                      (Key.t * 'a) list -> 'a t Base__.Or_error.t
                    val of_alist_exn : (Key.t * 'a) list -> 'a t
                    val of_alist_multi : (Key.t * 'a) list -> 'a list t
                    val of_alist_fold :
                      (Key.t * 'a) list ->
                      init:'-> f:('-> '-> 'b) -> 'b t
                    val of_alist_reduce :
                      (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                    val of_sorted_array :
                      (Key.t * 'a) array -> 'a t Base__.Or_error.t
                    val of_sorted_array_unchecked :
                      (Key.t * 'a) array -> 'a t
                    val of_increasing_iterator_unchecked :
                      len:int -> f:(int -> Key.t * 'a) -> 'a t
                    val of_iteri :
                      iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                      [ `Duplicate_key of Key.t | `Ok of 'v t ]
                    val of_tree : 'Tree.t -> 'a t
                    val of_hashtbl_exn :
                      (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                    val gen :
                      Key.t Core_kernel__.Quickcheck.Generator.t ->
                      'Core_kernel__.Quickcheck.Generator.t ->
                      'a t Core_kernel__.Quickcheck.Generator.t
                    val invariants : 'a t -> bool
                    val is_empty : 'a t -> bool
                    val length : 'a t -> int
                    val add : 'a t -> key:Key.t -> data:'-> 'a t
                    val add_multi :
                      'a list t -> key:Key.t -> data:'-> 'a list t
                    val remove_multi : 'a list t -> Key.t -> 'a list t
                    val change :
                      'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                    val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                    val find : 'a t -> Key.t -> 'a option
                    val find_exn : 'a t -> Key.t -> 'a
                    val remove : 'a t -> Key.t -> 'a t
                    val mem : 'a t -> Key.t -> bool
                    val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                    val iter : 'a t -> f:('-> unit) -> unit
                    val iteri :
                      'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                    val iter2 :
                      'a t ->
                      'b t ->
                      f:(key:Key.t ->
                         data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                         unit) ->
                      unit
                    val map : 'a t -> f:('-> 'b) -> 'b t
                    val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                    val fold :
                      'a t ->
                      init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                    val fold_right :
                      'a t ->
                      init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                    val fold2 :
                      'a t ->
                      'b t ->
                      init:'->
                      f:(key:Key.t ->
                         data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                         '-> 'c) ->
                      'c
                    val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                    val filter : 'a t -> f:('-> bool) -> 'a t
                    val filteri :
                      'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                    val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                    val filter_mapi :
                      'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                    val partition_mapi :
                      'a t ->
                      f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                      'b t * 'c t
                    val partition_map :
                      'a t ->
                      f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                    val partitioni_tf :
                      'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                    val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                    val compare_direct :
                      ('-> '-> int) -> 'a t -> 'a t -> int
                    val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                    val keys : 'a t -> Key.t list
                    val data : 'a t -> 'a list
                    val to_alist :
                      ?key_order:[ `Decreasing | `Increasing ] ->
                      'a t -> (Key.t * 'a) list
                    val validate :
                      name:(Key.t -> string) ->
                      'Base__.Validate.check -> 'a t Base__.Validate.check
                    val merge :
                      'a t ->
                      'b t ->
                      f:(key:Key.t ->
                         [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                         'c option) ->
                      'c t
                    val symmetric_diff :
                      'a t ->
                      'a t ->
                      data_equal:('-> '-> bool) ->
                      (Key.t, 'a)
                      Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                      Base__.Sequence.t
                    val min_elt : 'a t -> (Key.t * 'a) option
                    val min_elt_exn : 'a t -> Key.t * 'a
                    val max_elt : 'a t -> (Key.t * 'a) option
                    val max_elt_exn : 'a t -> Key.t * 'a
                    val for_all : 'a t -> f:('-> bool) -> bool
                    val for_alli :
                      'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                    val exists : 'a t -> f:('-> bool) -> bool
                    val existsi :
                      'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                    val count : 'a t -> f:('-> bool) -> int
                    val counti :
                      'a t -> f:(key:Key.t -> data:'-> bool) -> int
                    val split :
                      'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                    val append :
                      lower_part:'a t ->
                      upper_part:'a t ->
                      [ `Ok of 'a t | `Overlapping_key_ranges ]
                    val subrange :
                      'a t ->
                      lower_bound:Key.t Base__.Maybe_bound.t ->
                      upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                    val fold_range_inclusive :
                      'a t ->
                      min:Key.t ->
                      max:Key.t ->
                      init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                    val range_to_alist :
                      'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                    val closest_key :
                      'a t ->
                      [ `Greater_or_equal_to
                      | `Greater_than
                      | `Less_or_equal_to
                      | `Less_than ] -> Key.t -> (Key.t * 'a) option
                    val nth : 'a t -> int -> (Key.t * 'a) option
                    val nth_exn : 'a t -> int -> Key.t * 'a
                    val rank : 'a t -> Key.t -> int option
                    val to_tree : 'a t -> 'Tree.t
                    val to_sequence :
                      ?order:[ `Decreasing_key | `Increasing_key ] ->
                      ?keys_greater_or_equal_to:Key.t ->
                      ?keys_less_or_equal_to:Key.t ->
                      'a t -> (Key.t * 'a) Base__.Sequence.t
                    val obs :
                      Key.t Core_kernel__.Quickcheck.Observer.t ->
                      'Core_kernel__.Quickcheck.Observer.t ->
                      'v t Core_kernel__.Quickcheck.Observer.t
                    val shrinker :
                      Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                      'Core_kernel__.Quickcheck.Shrinker.t ->
                      'v t Core_kernel__.Quickcheck.Shrinker.t
                    module Provide_of_sexp :
                      functor
                        (Key : sig
                                 val t_of_sexp : Sexplib.Sexp.t -> Key.t
                               end->
                        sig
                          val t_of_sexp :
                            (Sexplib.Sexp.t -> 'v_x__018_) ->
                            Sexplib.Sexp.t -> 'v_x__018_ t
                        end
                    module Provide_bin_io :
                      functor
                        (Key : sig
                                 val bin_t : Key.t Bin_prot.Type_class.t
                                 val bin_read_t : Key.t Bin_prot.Read.reader
                                 val __bin_read_t__ :
                                   (Core_kernel__.Import.int -> Key.t)
                                   Bin_prot.Read.reader
                                 val bin_reader_t :
                                   Key.t Bin_prot.Type_class.reader
                                 val bin_size_t : Key.t Bin_prot.Size.sizer
                                 val bin_write_t :
                                   Key.t Bin_prot.Write.writer
                                 val bin_writer_t :
                                   Key.t Bin_prot.Type_class.writer
                                 val bin_shape_t : Bin_prot.Shape.t
                               end->
                        sig
                          val bin_shape_t :
                            Bin_prot.Shape.t -> Bin_prot.Shape.t
                          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                          val __bin_read_t__ :
                            ('a, int -> 'a t) Bin_prot.Read.reader1
                          val bin_writer_t :
                            ('a, 'a t) Bin_prot.Type_class.S1.writer
                          val bin_reader_t :
                            ('a, 'a t) Bin_prot.Type_class.S1.reader
                          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                        end
                    module Provide_hash :
                      functor
                        (Key : sig
                                 val hash_fold_t :
                                   Base__.Hash.state ->
                                   Key.t -> Base__.Hash.state
                               end->
                        sig
                          val hash_fold_t :
                            (Ppx_hash_lib.Std.Hash.state ->
                             '-> Ppx_hash_lib.Std.Hash.state) ->
                            Ppx_hash_lib.Std.Hash.state ->
                            'a t -> Ppx_hash_lib.Std.Hash.state
                        end
                    val t_of_sexp :
                      (Base__.Sexplib.Sexp.t -> 'a) ->
                      Base__.Sexplib.Sexp.t -> 'a t
                    val sexp_of_t :
                      ('-> Base__.Sexplib.Sexp.t) ->
                      'a t -> Base__.Sexplib.Sexp.t
                  end
                module Set :
                  sig
                    module Elt :
                      sig
                        type t = Edge.graph
                        val t_of_sexp : Sexplib.Sexp.t -> t
                        val sexp_of_t : t -> Sexplib.Sexp.t
                        type comparator_witness = Map.Key.comparator_witness
                        val comparator :
                          (t, comparator_witness)
                          Core_kernel__.Comparator.comparator
                      end
                    module Tree :
                      sig
                        type t =
                            (Elt.t, comparator_witness)
                            Core_kernel__.Core_set_intf.Tree.t
                        val compare : t -> t -> Core_kernel__.Import.int
                        val length : t -> int
                        val is_empty : t -> bool
                        val iter : t -> f:(Elt.t -> unit) -> unit
                        val fold :
                          t ->
                          init:'accum ->
                          f:('accum -> Elt.t -> 'accum) -> 'accum
                        val fold_result :
                          t ->
                          init:'accum ->
                          f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                          ('accum, 'e) Base__.Result.t
                        val exists : t -> f:(Elt.t -> bool) -> bool
                        val for_all : t -> f:(Elt.t -> bool) -> bool
                        val count : t -> f:(Elt.t -> bool) -> int
                        val sum :
                          (module Base__.Commutative_group.S with type t = 'sum) ->
                          t -> f:(Elt.t -> 'sum) -> 'sum
                        val find : t -> f:(Elt.t -> bool) -> Elt.t option
                        val find_map :
                          t -> f:(Elt.t -> 'a option) -> 'a option
                        val to_list : t -> Elt.t list
                        val to_array : t -> Elt.t array
                        val invariants : t -> bool
                        val mem : t -> Elt.t -> bool
                        val add : t -> Elt.t -> t
                        val remove : t -> Elt.t -> t
                        val union : t -> t -> t
                        val inter : t -> t -> t
                        val diff : t -> t -> t
                        val symmetric_diff :
                          t ->
                          t ->
                          (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                        val compare_direct : t -> t -> int
                        val equal : t -> t -> bool
                        val is_subset : t -> of_:t -> bool
                        val subset : t -> t -> bool
                        val fold_until :
                          t ->
                          init:'->
                          f:('->
                             Elt.t ->
                             ('b, 'stop)
                             Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                          ('b, 'stop)
                          Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                        val fold_right :
                          t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                        val iter2 :
                          t ->
                          t ->
                          f:([ `Both of Elt.t * Elt.t
                             | `Left of Elt.t
                             | `Right of Elt.t ] -> unit) ->
                          unit
                        val filter : t -> f:(Elt.t -> bool) -> t
                        val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                        val elements : t -> Elt.t list
                        val min_elt : t -> Elt.t option
                        val min_elt_exn : t -> Elt.t
                        val max_elt : t -> Elt.t option
                        val max_elt_exn : t -> Elt.t
                        val choose : t -> Elt.t option
                        val choose_exn : t -> Elt.t
                        val split : t -> Elt.t -> t * Elt.t option * t
                        val group_by :
                          t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                        val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                        val find_index : t -> int -> Elt.t option
                        val nth : t -> int -> Elt.t option
                        val remove_index : t -> int -> t
                        val to_tree : t -> t
                        val to_sequence :
                          ?order:[ `Decreasing | `Increasing ] ->
                          ?greater_or_equal_to:Elt.t ->
                          ?less_or_equal_to:Elt.t ->
                          t -> Elt.t Base__.Sequence.t
                        val merge_to_sequence :
                          ?order:[ `Decreasing | `Increasing ] ->
                          ?greater_or_equal_to:Elt.t ->
                          ?less_or_equal_to:Elt.t ->
                          t ->
                          t ->
                          (Elt.t, Elt.t)
                          Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                          Base__.Sequence.t
                        val to_map :
                          t ->
                          f:(Elt.t -> 'data) ->
                          (Elt.t, 'data, comparator_witness)
                          Core_kernel__.Core_set_intf.Map.t
                        val obs :
                          Elt.t Core_kernel__.Quickcheck.Observer.t ->
                          t Core_kernel__.Quickcheck.Observer.t
                        val shrinker :
                          Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                          t Core_kernel__.Quickcheck.Shrinker.t
                        val empty : t
                        val singleton : Elt.t -> t
                        val union_list : t list -> t
                        val of_list : Elt.t list -> t
                        val of_array : Elt.t array -> t
                        val of_sorted_array :
                          Elt.t array -> t Base__.Or_error.t
                        val of_sorted_array_unchecked : Elt.t array -> t
                        val of_increasing_iterator_unchecked :
                          len:int -> f:(int -> Elt.t) -> t
                        val stable_dedup_list : Elt.t list -> Elt.t list
                        val map :
                          ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                          f:('-> Elt.t) -> t
                        val filter_map :
                          ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                          f:('-> Elt.t option) -> t
                        val of_tree : t -> t
                        val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                        val of_hashtbl_keys :
                          (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                        val of_map_keys :
                          (Elt.t, 'a, comparator_witness)
                          Core_kernel__.Core_set_intf.Map.t -> t
                        val gen :
                          Elt.t Core_kernel__.Quickcheck.Generator.t ->
                          t Core_kernel__.Quickcheck.Generator.t
                        module Provide_of_sexp :
                          functor
                            (Elt : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> Elt.t
                                   end->
                            sig val t_of_sexp : Sexplib.Sexp.t -> t end
                        val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                        val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                      end
                    type t = (Elt.t, comparator_witness) Base.Set.t
                    val compare : t -> t -> Core_kernel__.Import.int
                    val length : t -> int
                    val is_empty : t -> bool
                    val iter : t -> f:(Elt.t -> unit) -> unit
                    val fold :
                      t ->
                      init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                    val fold_result :
                      t ->
                      init:'accum ->
                      f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                      ('accum, 'e) Base__.Result.t
                    val exists : t -> f:(Elt.t -> bool) -> bool
                    val for_all : t -> f:(Elt.t -> bool) -> bool
                    val count : t -> f:(Elt.t -> bool) -> int
                    val sum :
                      (module Base__.Commutative_group.S with type t = 'sum) ->
                      t -> f:(Elt.t -> 'sum) -> 'sum
                    val find : t -> f:(Elt.t -> bool) -> Elt.t option
                    val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                    val to_list : t -> Elt.t list
                    val to_array : t -> Elt.t array
                    val invariants : t -> bool
                    val mem : t -> Elt.t -> bool
                    val add : t -> Elt.t -> t
                    val remove : t -> Elt.t -> t
                    val union : t -> t -> t
                    val inter : t -> t -> t
                    val diff : t -> t -> t
                    val symmetric_diff :
                      t ->
                      t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                    val compare_direct : t -> t -> int
                    val equal : t -> t -> bool
                    val is_subset : t -> of_:t -> bool
                    val subset : t -> t -> bool
                    val fold_until :
                      t ->
                      init:'->
                      f:('->
                         Elt.t ->
                         ('b, 'stop)
                         Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                      ('b, 'stop)
                      Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                    val fold_right :
                      t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                    val iter2 :
                      t ->
                      t ->
                      f:([ `Both of Elt.t * Elt.t
                         | `Left of Elt.t
                         | `Right of Elt.t ] -> unit) ->
                      unit
                    val filter : t -> f:(Elt.t -> bool) -> t
                    val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                    val elements : t -> Elt.t list
                    val min_elt : t -> Elt.t option
                    val min_elt_exn : t -> Elt.t
                    val max_elt : t -> Elt.t option
                    val max_elt_exn : t -> Elt.t
                    val choose : t -> Elt.t option
                    val choose_exn : t -> Elt.t
                    val split : t -> Elt.t -> t * Elt.t option * t
                    val group_by :
                      t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                    val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                    val find_index : t -> int -> Elt.t option
                    val nth : t -> int -> Elt.t option
                    val remove_index : t -> int -> t
                    val to_tree : t -> Tree.t
                    val to_sequence :
                      ?order:[ `Decreasing | `Increasing ] ->
                      ?greater_or_equal_to:Elt.t ->
                      ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                    val merge_to_sequence :
                      ?order:[ `Decreasing | `Increasing ] ->
                      ?greater_or_equal_to:Elt.t ->
                      ?less_or_equal_to:Elt.t ->
                      t ->
                      t ->
                      (Elt.t, Elt.t)
                      Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                      Base__.Sequence.t
                    val to_map :
                      t ->
                      f:(Elt.t -> 'data) ->
                      (Elt.t, 'data, comparator_witness)
                      Core_kernel__.Core_set_intf.Map.t
                    val obs :
                      Elt.t Core_kernel__.Quickcheck.Observer.t ->
                      t Core_kernel__.Quickcheck.Observer.t
                    val shrinker :
                      Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                      t Core_kernel__.Quickcheck.Shrinker.t
                    val empty : t
                    val singleton : Elt.t -> t
                    val union_list : t list -> t
                    val of_list : Elt.t list -> t
                    val of_array : Elt.t array -> t
                    val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                    val of_sorted_array_unchecked : Elt.t array -> t
                    val of_increasing_iterator_unchecked :
                      len:int -> f:(int -> Elt.t) -> t
                    val stable_dedup_list : Elt.t list -> Elt.t list
                    val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
                    val filter_map :
                      ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
                    val of_tree : Tree.t -> t
                    val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                    val of_hashtbl_keys :
                      (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                    val of_map_keys :
                      (Elt.t, 'a, comparator_witness)
                      Core_kernel__.Core_set_intf.Map.t -> t
                    val gen :
                      Elt.t Core_kernel__.Quickcheck.Generator.t ->
                      t Core_kernel__.Quickcheck.Generator.t
                    module Provide_of_sexp :
                      functor
                        (Elt : sig
                                 val t_of_sexp : Sexplib.Sexp.t -> Elt.t
                               end->
                        sig val t_of_sexp : Sexplib.Sexp.t -> t end
                    module Provide_bin_io :
                      functor
                        (Elt : sig
                                 val bin_t : Elt.t Bin_prot.Type_class.t
                                 val bin_read_t : Elt.t Bin_prot.Read.reader
                                 val __bin_read_t__ :
                                   (Core_kernel__.Import.int -> Elt.t)
                                   Bin_prot.Read.reader
                                 val bin_reader_t :
                                   Elt.t Bin_prot.Type_class.reader
                                 val bin_size_t : Elt.t Bin_prot.Size.sizer
                                 val bin_write_t :
                                   Elt.t Bin_prot.Write.writer
                                 val bin_writer_t :
                                   Elt.t Bin_prot.Type_class.writer
                                 val bin_shape_t : Bin_prot.Shape.t
                               end->
                        sig
                          val bin_size_t : t Bin_prot.Size.sizer
                          val bin_write_t : t Bin_prot.Write.writer
                          val bin_read_t : t Bin_prot.Read.reader
                          val __bin_read_t__ :
                            (int -> t) Bin_prot.Read.reader
                          val bin_shape_t : Bin_prot.Shape.t
                          val bin_writer_t : t Bin_prot.Type_class.writer
                          val bin_reader_t : t Bin_prot.Type_class.reader
                          val bin_t : t Bin_prot.Type_class.t
                        end
                    module Provide_hash :
                      functor
                        (Elt : sig
                                 val hash_fold_t :
                                   Base__.Hash.state ->
                                   Elt.t -> Base__.Hash.state
                               end->
                        sig
                          val hash_fold_t :
                            Ppx_hash_lib.Std.Hash.state ->
                            t -> Ppx_hash_lib.Std.Hash.state
                          val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                        end
                    val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                    val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  end
                val hash : t -> Core_kernel__.Import.int
                val compare : t -> t -> Core_kernel__.Import.int
                val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
                module Table :
                  sig
                    type key = t
                    type ('a, 'b) hashtbl = ('a, 'b) Edge.Table.hashtbl
                    type 'b t = (key, 'b) hashtbl
                    val sexp_of_t :
                      ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                    type ('a, 'b) t_ = 'b t
                    type 'a key_ = key
                    val hashable :
                      key Core_kernel__.Core_hashtbl_intf.Hashable.t
                    val invariant :
                      'Base__.Invariant_intf.inv ->
                      'a t Base__.Invariant_intf.inv
                    val create :
                      (key, 'b, unit -> 'b t)
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val of_alist :
                      (key, 'b,
                       (key * 'b) list ->
                       [ `Duplicate_key of key | `Ok of 'b t ])
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val of_alist_report_all_dups :
                      (key, 'b,
                       (key * 'b) list ->
                       [ `Duplicate_keys of key list | `Ok of 'b t ])
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val of_alist_or_error :
                      (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val of_alist_exn :
                      (key, 'b, (key * 'b) list -> 'b t)
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val of_alist_multi :
                      (key, 'b list, (key * 'b) list -> 'b list t)
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val create_mapped :
                      (key, 'b,
                       get_key:('-> key) ->
                       get_data:('-> 'b) ->
                       'r list ->
                       [ `Duplicate_keys of key list | `Ok of 'b t ])
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val create_with_key :
                      (key, 'r,
                       get_key:('-> key) ->
                       'r list ->
                       [ `Duplicate_keys of key list | `Ok of 'r t ])
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val create_with_key_or_error :
                      (key, 'r,
                       get_key:('-> key) ->
                       'r list -> 'r t Base__.Or_error.t)
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val create_with_key_exn :
                      (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val group :
                      (key, 'b,
                       get_key:('-> key) ->
                       get_data:('-> 'b) ->
                       combine:('-> '-> 'b) -> 'r list -> 'b t)
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                    val clear : 'a t -> unit
                    val copy : 'b t -> 'b t
                    val fold :
                      'b t ->
                      init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                    val iter_keys : 'a t -> f:(key -> unit) -> unit
                    val iter : 'b t -> f:('-> unit) -> unit
                    val iteri :
                      'b t -> f:(key:key -> data:'-> unit) -> unit
                    val iter_vals : 'b t -> f:('-> unit) -> unit
                    val existsi :
                      'b t -> f:(key:key -> data:'-> bool) -> bool
                    val exists : 'b t -> f:('-> bool) -> bool
                    val for_alli :
                      'b t -> f:(key:key -> data:'-> bool) -> bool
                    val for_all : 'b t -> f:('-> bool) -> bool
                    val counti :
                      'b t -> f:(key:key -> data:'-> bool) -> int
                    val count : 'b t -> f:('-> bool) -> int
                    val length : 'a t -> int
                    val is_empty : 'a t -> bool
                    val mem : 'a t -> key -> bool
                    val remove : 'a t -> key -> unit
                    val replace : 'b t -> key:key -> data:'-> unit
                    val set : 'b t -> key:key -> data:'-> unit
                    val add :
                      'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                    val add_or_error :
                      'b t -> key:key -> data:'-> unit Base__.Or_error.t
                    val add_exn : 'b t -> key:key -> data:'-> unit
                    val change :
                      'b t -> key -> f:('b option -> 'b option) -> unit
                    val update : 'b t -> key -> f:('b option -> 'b) -> unit
                    val add_multi : 'b list t -> key:key -> data:'-> unit
                    val remove_multi : 'a list t -> key -> unit
                    val map : 'b t -> f:('-> 'c) -> 'c t
                    val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                    val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                    val filter_mapi :
                      'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                    val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                    val filter : 'b t -> f:('-> bool) -> 'b t
                    val filteri :
                      'b t -> f:(key:key -> data:'-> bool) -> 'b t
                    val partition_map :
                      'b t ->
                      f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                    val partition_mapi :
                      'b t ->
                      f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                      'c t * 'd t
                    val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
                    val partitioni_tf :
                      'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                    val find_or_add :
                      'b t -> key -> default:(unit -> 'b) -> 'b
                    val find : 'b t -> key -> 'b option
                    val find_exn : 'b t -> key -> 'b
                    val find_and_call :
                      'b t ->
                      key ->
                      if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                    val find_and_remove : 'b t -> key -> 'b option
                    val merge :
                      'a t ->
                      'b t ->
                      f:(key:key ->
                         [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                         'c option) ->
                      'c t
                    type 'a merge_into_action = Remove | Set_to of 'a
                    val merge_into :
                      src:'a t ->
                      dst:'b t ->
                      f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                      unit
                    val keys : 'a t -> key list
                    val data : 'b t -> 'b list
                    val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
                    val filter_inplace : 'b t -> f:('-> bool) -> unit
                    val filteri_inplace :
                      'b t -> f:(key:key -> data:'-> bool) -> unit
                    val map_inplace : 'b t -> f:('-> 'b) -> unit
                    val mapi_inplace :
                      'b t -> f:(key:key -> data:'-> 'b) -> unit
                    val filter_map_inplace :
                      'b t -> f:('-> 'b option) -> unit
                    val filter_mapi_inplace :
                      'b t -> f:(key:key -> data:'-> 'b option) -> unit
                    val replace_all : 'b t -> f:('-> 'b) -> unit
                    val replace_alli :
                      'b t -> f:(key:key -> data:'-> 'b) -> unit
                    val filter_replace_all :
                      'b t -> f:('-> 'b option) -> unit
                    val filter_replace_alli :
                      'b t -> f:(key:key -> data:'-> 'b option) -> unit
                    val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                    val similar :
                      'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                    val to_alist : 'b t -> (key * 'b) list
                    val validate :
                      name:(key -> string) ->
                      'Base__.Validate.check -> 'b t Base__.Validate.check
                    val incr :
                      ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                    val decr :
                      ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                    module Provide_of_sexp :
                      functor
                        (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                        sig
                          val t_of_sexp :
                            (Sexplib.Sexp.t -> 'v_x__001_) ->
                            Sexplib.Sexp.t -> 'v_x__001_ t
                        end
                    module Provide_bin_io :
                      functor
                        (Key : sig
                                 val bin_t : key Bin_prot.Type_class.t
                                 val bin_read_t : key Bin_prot.Read.reader
                                 val __bin_read_t__ :
                                   (Core_kernel__.Import.int -> key)
                                   Bin_prot.Read.reader
                                 val bin_reader_t :
                                   key Bin_prot.Type_class.reader
                                 val bin_size_t : key Bin_prot.Size.sizer
                                 val bin_write_t : key Bin_prot.Write.writer
                                 val bin_writer_t :
                                   key Bin_prot.Type_class.writer
                                 val bin_shape_t : Bin_prot.Shape.t
                               end->
                        sig
                          val bin_t :
                            'Bin_prot.Type_class.t ->
                            'a t Bin_prot.Type_class.t
                          val bin_read_t :
                            'Bin_prot.Read.reader ->
                            'a t Bin_prot.Read.reader
                          val __bin_read_t__ :
                            'Bin_prot.Read.reader ->
                            (Core_kernel__.Import.int -> 'a t)
                            Bin_prot.Read.reader
                          val bin_reader_t :
                            'Bin_prot.Type_class.reader ->
                            'a t Bin_prot.Type_class.reader
                          val bin_size_t :
                            'Bin_prot.Size.sizer ->
                            'a t Bin_prot.Size.sizer
                          val bin_write_t :
                            'Bin_prot.Write.writer ->
                            'a t Bin_prot.Write.writer
                          val bin_writer_t :
                            'Bin_prot.Type_class.writer ->
                            'a t Bin_prot.Type_class.writer
                          val bin_shape_t :
                            Bin_prot.Shape.t -> Bin_prot.Shape.t
                        end
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__002_) ->
                      Sexplib.Sexp.t -> 'v_x__002_ t
                  end
                module Hash_set :
                  sig
                    type elt = t
                    type t = elt Core_kernel__.Hash_set.t
                    val sexp_of_t : t -> Sexplib.Sexp.t
                    type 'a t_ = t
                    type 'a elt_ = elt
                    val create :
                      ('a, unit -> t)
                      Core_kernel__.Hash_set_intf.create_options_without_hashable
                    val of_list :
                      ('a, elt list -> t)
                      Core_kernel__.Hash_set_intf.create_options_without_hashable
                    module Provide_of_sexp :
                      functor
                        (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                        sig val t_of_sexp : Sexplib.Sexp.t -> t end
                    module Provide_bin_io :
                      functor
                        (X : sig
                               val bin_t : elt Bin_prot.Type_class.t
                               val bin_read_t : elt Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> elt)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 elt Bin_prot.Type_class.reader
                               val bin_size_t : elt Bin_prot.Size.sizer
                               val bin_write_t : elt Bin_prot.Write.writer
                               val bin_writer_t :
                                 elt Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                        sig
                          val bin_t : t Bin_prot.Type_class.t
                          val bin_read_t : t Bin_prot.Read.reader
                          val __bin_read_t__ :
                            (Core_kernel__.Import.int -> t)
                            Bin_prot.Read.reader
                          val bin_reader_t : t Bin_prot.Type_class.reader
                          val bin_size_t : t Bin_prot.Size.sizer
                          val bin_write_t : t Bin_prot.Write.writer
                          val bin_writer_t : t Bin_prot.Type_class.writer
                          val bin_shape_t : Bin_prot.Shape.t
                        end
                    val t_of_sexp : Sexplib.Sexp.t -> t
                  end
                module Hash_queue :
                  sig
                    module Key :
                      sig
                        type t = Hash_set.elt
                        val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                        val compare : t -> t -> int
                        val hash : t -> int
                      end
                    type 'a t
                    val sexp_of_t :
                      ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                    val length : 'a t -> int
                    val is_empty : 'a t -> bool
                    val iter : 'a t -> f:('-> unit) -> unit
                    val fold :
                      'a t ->
                      init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                    val fold_result :
                      'a t ->
                      init:'accum ->
                      f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                      ('accum, 'e) Base__.Result.t
                    val fold_until :
                      'a t ->
                      init:'accum ->
                      f:('accum ->
                         '->
                         ('accum, 'stop)
                         Base.Container_intf.Continue_or_stop.t) ->
                      ('accum, 'stop)
                      Base.Container_intf.Finished_or_stopped_early.t
                    val exists : 'a t -> f:('-> bool) -> bool
                    val for_all : 'a t -> f:('-> bool) -> bool
                    val count : 'a t -> f:('-> bool) -> int
                    val sum :
                      (module Base__.Commutative_group.S with type t = 'sum) ->
                      'a t -> f:('-> 'sum) -> 'sum
                    val find : 'a t -> f:('-> bool) -> 'a option
                    val find_map : 'a t -> f:('-> 'b option) -> 'b option
                    val to_list : 'a t -> 'a list
                    val to_array : 'a t -> 'a array
                    val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
                    val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
                    val invariant : 'a t -> Core_kernel__.Import.unit
                    val create :
                      ?growth_allowed:Core_kernel__.Import.bool ->
                      ?size:Core_kernel__.Import.int ->
                      Core_kernel__.Import.unit -> 'a t
                    val clear : 'a t -> Core_kernel__.Import.unit
                    val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
                    val lookup :
                      'a t -> Key.t -> 'Core_kernel__.Import.option
                    val lookup_exn : 'a t -> Key.t -> 'a
                    val enqueue :
                      'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
                    val enqueue_exn :
                      'a t -> Key.t -> '-> Core_kernel__.Import.unit
                    val lookup_and_move_to_back :
                      'a t -> Key.t -> 'Core_kernel__.Import.option
                    val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
                    val first : 'a t -> 'Core_kernel__.Import.option
                    val first_with_key :
                      'a t -> (Key.t * 'a) Core_kernel__.Import.option
                    val keys : 'a t -> Key.t Core_kernel__.Import.list
                    val dequeue : 'a t -> 'Core_kernel__.Import.option
                    val dequeue_exn : 'a t -> 'a
                    val dequeue_with_key :
                      'a t -> (Key.t * 'a) Core_kernel__.Import.option
                    val dequeue_with_key_exn : 'a t -> Key.t * 'a
                    val dequeue_all :
                      'a t ->
                      f:('-> Core_kernel__.Import.unit) ->
                      Core_kernel__.Import.unit
                    val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
                    val remove_exn :
                      'a t -> Key.t -> Core_kernel__.Import.unit
                    val replace :
                      'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
                    val replace_exn :
                      'a t -> Key.t -> '-> Core_kernel__.Import.unit
                    val iteri :
                      'a t ->
                      f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                      Core_kernel__.Import.unit
                    val foldi :
                      'a t ->
                      init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
                  end
                val to_string : t -> string
                val str : unit -> t -> string
                val pps : unit -> t -> string
                val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
                val pp_seq :
                  Format.formatter -> t Core_kernel.Std.Sequence.t -> unit
                val pp : Base__.Import.Caml.Format.formatter -> t -> unit
              end
          val create :
            (module Graphlib.Std.Graph with type t = 'and type Edge.label = 'and type Node.label = 'a) ->
            ?nodes:'a list -> ?edges:('a * 'a * 'b) list -> unit -> 'c
          val union :
            (module Graphlib.Std.Graph with type edge = 'and type node = 'and type t = 'c) ->
            '-> '-> 'c
          val inter :
            (module Graphlib.Std.Graph with type edge = 'and type node = 'and type t = 'c) ->
            '-> '-> 'c
          val to_dot :
            (module Graphlib.Std.Graph with type edge = 'and type node = 'and type t = 'c) ->
            ?graph_attrs:('-> Graphlib.Std.graph_attr list) ->
            ?node_attrs:('-> Graphlib.Std.node_attr list) ->
            ?edge_attrs:('-> Graphlib.Std.edge_attr list) ->
            ?string_of_node:('-> string) ->
            ?string_of_edge:('-> string) ->
            ?channel:Core_kernel.Std.Out_channel.t ->
            ?formatter:Format.formatter -> ?filename:string -> '-> unit
          val depth_first_search :
            (module Graphlib.Std.Graph with type edge = 'and type node = 'and type t = 'c) ->
            ?rev:bool ->
            ?start:'->
            ?start_tree:('-> '-> 's) ->
            ?enter_node:(int -> '-> '-> 's) ->
            ?leave_node:(int -> '-> '-> 's) ->
            ?enter_edge:(Graphlib.Std.edge_kind -> '-> '-> 's) ->
            ?leave_edge:(Graphlib.Std.edge_kind -> '-> '-> 's) ->
            '-> init:'-> 's
          val depth_first_visit :
            (module Graphlib.Std.Graph with type edge = 'and type node = 'and type t = 'c) ->
            ?rev:bool ->
            ?start:'->
            '-> init:'-> ('n, 'e, 's) Graphlib.Std.dfs_visitor -> 's
          class ['n, 'e, 's] dfs_identity_visitor : ['n, 'e, 's] dfs_visitor
          val reverse_postorder_traverse :
            (module Graphlib.Std.Graph with type edge = 'and type node = 'and type t = 'c) ->
            ?rev:bool -> ?start:'-> '-> 'Regular.Std.seq
          val postorder_traverse :
            (module Graphlib.Std.Graph with type edge = 'and type node = 'and type t = 'c) ->
            ?rev:bool -> ?start:'-> '-> 'Regular.Std.seq
          val dominators :
            (module Graphlib.Std.Graph with type edge = 'and type node = 'and type t = 'c) ->
            ?rev:bool -> '-> '-> 'Graphlib.Std.tree
          val dom_frontier :
            (module Graphlib.Std.Graph with type edge = 'and type node = 'and type t = 'c) ->
            ?rev:bool ->
            '-> 'Graphlib.Std.tree -> 'Graphlib.Std.frontier
          val strong_components :
            (module Graphlib.Std.Graph with type edge = 'and type node = 'and type t = 'c) ->
            '-> 'Graphlib.Std.partition
          val shortest_path :
            (module Graphlib.Std.Graph with type edge = 'and type node = 'and type t = 'c) ->
            ?weight:('-> int) ->
            ?rev:bool -> '-> '-> '-> 'Graphlib.Std.path option
          val is_reachable :
            (module Graphlib.Std.Graph with type edge = 'and type node = 'and type t = 'c) ->
            ?rev:bool -> '-> '-> '-> bool
          val fold_reachable :
            (module Graphlib.Std.Graph with type edge = 'and type node = 'and type t = 'c) ->
            ?rev:bool -> init:'-> f:('-> '-> 'a) -> '-> '-> 'a
          val compare :
            (module Graphlib.Std.Graph with type node = 'and type t = 'a) ->
            (module Graphlib.Std.Graph with type node = 'and type t = 'b) ->
            '-> '-> int
          val filtered :
            (module Graphlib.Std.Graph with type edge = 'and type node = 'and type t = 'c) ->
            ?skip_node:('-> bool) ->
            ?skip_edge:('-> bool) ->
            unit ->
            (module Graphlib.Std.Graph with type edge = 'and type node = 'and type t = 'c)
          val view :
            (module Graphlib.Std.Graph with type edge = 'and type node = 'and type t = 'and type Edge.label = 'and type Node.label = 'a) ->
            node:('-> 'f) * ('-> 'n) ->
            edge:('-> 'd) * ('-> 'e) ->
            node_label:('-> 'p) * ('-> 'a) ->
            edge_label:('-> 'r) * ('-> 'b) ->
            (module Graphlib.Std.Graph with type edge = 'and type node = 'and type t = 'and type Edge.label = 'and type Node.label = 'p)
          module To_ocamlgraph :
            functor (G : Graph->
              sig
                type t = G.t
                module V :
                  sig
                    type t = G.node
                    val compare : t -> t -> int
                    val hash : t -> int
                    val equal : t -> t -> bool
                    type label = G.Node.label
                    val create : label -> t
                    val label : t -> label
                  end
                type vertex = V.t
                module E :
                  sig
                    type t = G.edge
                    val compare : t -> t -> int
                    type vertex = V.t
                    val src : t -> vertex
                    val dst : t -> vertex
                    type label = G.Edge.label
                    val create : vertex -> label -> vertex -> t
                    val label : t -> label
                  end
                type edge = E.t
                val is_directed : bool
                val is_empty : t -> bool
                val nb_vertex : t -> int
                val nb_edges : t -> int
                val out_degree : t -> vertex -> int
                val in_degree : t -> vertex -> int
                val mem_vertex : t -> vertex -> bool
                val mem_edge : t -> vertex -> vertex -> bool
                val mem_edge_e : t -> edge -> bool
                val find_edge : t -> vertex -> vertex -> edge
                val find_all_edges : t -> vertex -> vertex -> edge list
                val succ : t -> vertex -> vertex list
                val pred : t -> vertex -> vertex list
                val succ_e : t -> vertex -> edge list
                val pred_e : t -> vertex -> edge list
                val iter_vertex : (vertex -> unit) -> t -> unit
                val fold_vertex : (vertex -> '-> 'a) -> t -> '-> 'a
                val iter_edges : (vertex -> vertex -> unit) -> t -> unit
                val fold_edges :
                  (vertex -> vertex -> '-> 'a) -> t -> '-> 'a
                val iter_edges_e : (edge -> unit) -> t -> unit
                val fold_edges_e : (edge -> '-> 'a) -> t -> '-> 'a
                val map_vertex : (vertex -> vertex) -> t -> t
                val iter_succ : (vertex -> unit) -> t -> vertex -> unit
                val iter_pred : (vertex -> unit) -> t -> vertex -> unit
                val fold_succ :
                  (vertex -> '-> 'a) -> t -> vertex -> '-> 'a
                val fold_pred :
                  (vertex -> '-> 'a) -> t -> vertex -> '-> 'a
                val iter_succ_e : (edge -> unit) -> t -> vertex -> unit
                val fold_succ_e :
                  (edge -> '-> 'a) -> t -> vertex -> '-> 'a
                val iter_pred_e : (edge -> unit) -> t -> vertex -> unit
                val fold_pred_e :
                  (edge -> '-> 'a) -> t -> vertex -> '-> 'a
                val empty : t
                val add_vertex : t -> vertex -> t
                val remove_vertex : t -> vertex -> t
                val add_edge : t -> vertex -> vertex -> t
                val add_edge_e : t -> edge -> t
                val remove_edge : t -> vertex -> vertex -> t
                val remove_edge_e : t -> edge -> t
              end
          module Of_ocamlgraph :
            functor (G : Graph.Sig.P->
              sig
                type t = G.t
                type node = G.V.t
                type edge = G.E.t
                module Node :
                  sig
                    type t = node
                    type graph = G.t
                    type label = G.V.label
                    type edge = G.E.t
                    val create : label -> t
                    val label : t -> label
                    val mem : t -> graph -> bool
                    val succs : t -> graph -> t Regular.Std.seq
                    val preds : t -> graph -> t Regular.Std.seq
                    val inputs : t -> graph -> edge Regular.Std.seq
                    val outputs : t -> graph -> edge Regular.Std.seq
                    val degree : ?dir:[ `In | `Out ] -> t -> graph -> int
                    val insert : t -> graph -> graph
                    val update : t -> label -> graph -> graph
                    val remove : t -> graph -> graph
                    val has_edge : t -> t -> graph -> bool
                    val edge : t -> t -> graph -> edge option
                    val ( >= ) : t -> t -> bool
                    val ( <= ) : t -> t -> bool
                    val ( = ) : t -> t -> bool
                    val ( > ) : t -> t -> bool
                    val ( < ) : t -> t -> bool
                    val ( <> ) : t -> t -> bool
                    val equal : t -> t -> bool
                    val min : t -> t -> t
                    val max : t -> t -> t
                    val ascending : t -> t -> int
                    val descending : t -> t -> int
                    val between : t -> low:t -> high:t -> bool
                    val clamp_exn : t -> min:t -> max:t -> t
                    val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
                    type comparator_witness
                    val comparator :
                      (t, comparator_witness) Base__.Comparator.comparator
                    val validate_lbound :
                      min:t Base__.Maybe_bound.t -> t Base__.Validate.check
                    val validate_ubound :
                      max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                    val validate_bound :
                      min:t Base__.Maybe_bound.t ->
                      max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                    module Replace_polymorphic_compare :
                      sig
                        val ( >= ) : t -> t -> bool
                        val ( <= ) : t -> t -> bool
                        val ( = ) : t -> t -> bool
                        val ( > ) : t -> t -> bool
                        val ( < ) : t -> t -> bool
                        val ( <> ) : t -> t -> bool
                        val equal : t -> t -> bool
                        val compare : t -> t -> int
                        val min : t -> t -> t
                        val max : t -> t -> t
                      end
                    module Map :
                      sig
                        module Key :
                          sig
                            type t = node
                            val t_of_sexp : Sexplib.Sexp.t -> t
                            val sexp_of_t : t -> Sexplib.Sexp.t
                            type comparator_witness = comparator_witness
                            val comparator :
                              (t, comparator_witness)
                              Core_kernel__.Comparator.comparator
                          end
                        module Tree :
                          sig
                            type 'a t =
                                (node, 'a, comparator_witness)
                                Core_kernel__.Core_map_intf.Tree.t
                            val empty : 'a t
                            val singleton : node -> '-> 'a t
                            val of_alist :
                              (node * 'a) list ->
                              [ `Duplicate_key of node | `Ok of 'a t ]
                            val of_alist_or_error :
                              (node * 'a) list -> 'a t Base__.Or_error.t
                            val of_alist_exn : (node * 'a) list -> 'a t
                            val of_alist_multi :
                              (node * 'a) list -> 'a list t
                            val of_alist_fold :
                              (node * 'a) list ->
                              init:'-> f:('-> '-> 'b) -> 'b t
                            val of_alist_reduce :
                              (node * 'a) list -> f:('-> '-> 'a) -> 'a t
                            val of_sorted_array :
                              (node * 'a) array -> 'a t Base__.Or_error.t
                            val of_sorted_array_unchecked :
                              (node * 'a) array -> 'a t
                            val of_increasing_iterator_unchecked :
                              len:int -> f:(int -> node * 'a) -> 'a t
                            val of_iteri :
                              iteri:(f:(key:node -> data:'-> unit) -> unit) ->
                              [ `Duplicate_key of node | `Ok of 'v t ]
                            val of_tree : 'a t -> 'a t
                            val of_hashtbl_exn :
                              (node, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                            val gen :
                              node Core_kernel__.Quickcheck.Generator.t ->
                              'Core_kernel__.Quickcheck.Generator.t ->
                              'a t Core_kernel__.Quickcheck.Generator.t
                            val invariants : 'a t -> bool
                            val is_empty : 'a t -> bool
                            val length : 'a t -> int
                            val add : 'a t -> key:node -> data:'-> 'a t
                            val add_multi :
                              'a list t -> key:node -> data:'-> 'a list t
                            val remove_multi : 'a list t -> node -> 'a list t
                            val change :
                              'a t ->
                              node -> f:('a option -> 'a option) -> 'a t
                            val update :
                              'a t -> node -> f:('a option -> 'a) -> 'a t
                            val find : 'a t -> node -> 'a option
                            val find_exn : 'a t -> node -> 'a
                            val remove : 'a t -> node -> 'a t
                            val mem : 'a t -> node -> bool
                            val iter_keys : 'a t -> f:(node -> unit) -> unit
                            val iter : 'a t -> f:('-> unit) -> unit
                            val iteri :
                              'a t -> f:(key:node -> data:'-> unit) -> unit
                            val iter2 :
                              'a t ->
                              'b t ->
                              f:(key:node ->
                                 data:[ `Both of 'a * 'b
                                      | `Left of 'a
                                      | `Right of 'b ] ->
                                 unit) ->
                              unit
                            val map : 'a t -> f:('-> 'b) -> 'b t
                            val mapi :
                              'a t -> f:(key:node -> data:'-> 'b) -> 'b t
                            val fold :
                              'a t ->
                              init:'->
                              f:(key:node -> data:'-> '-> 'b) -> 'b
                            val fold_right :
                              'a t ->
                              init:'->
                              f:(key:node -> data:'-> '-> 'b) -> 'b
                            val fold2 :
                              'a t ->
                              'b t ->
                              init:'->
                              f:(key:node ->
                                 data:[ `Both of 'a * 'b
                                      | `Left of 'a
                                      | `Right of 'b ] ->
                                 '-> 'c) ->
                              'c
                            val filter_keys :
                              'a t -> f:(node -> bool) -> 'a t
                            val filter : 'a t -> f:('-> bool) -> 'a t
                            val filteri :
                              'a t -> f:(key:node -> data:'-> bool) -> 'a t
                            val filter_map :
                              'a t -> f:('-> 'b option) -> 'b t
                            val filter_mapi :
                              'a t ->
                              f:(key:node -> data:'-> 'b option) -> 'b t
                            val partition_mapi :
                              'a t ->
                              f:(key:node ->
                                 data:'-> [ `Fst of '| `Snd of 'c ]) ->
                              'b t * 'c t
                            val partition_map :
                              'a t ->
                              f:('-> [ `Fst of '| `Snd of 'c ]) ->
                              'b t * 'c t
                            val partitioni_tf :
                              'a t ->
                              f:(key:node -> data:'-> bool) -> 'a t * 'a t
                            val partition_tf :
                              'a t -> f:('-> bool) -> 'a t * 'a t
                            val compare_direct :
                              ('-> '-> int) -> 'a t -> 'a t -> int
                            val equal :
                              ('-> '-> bool) -> 'a t -> 'a t -> bool
                            val keys : 'a t -> node list
                            val data : 'a t -> 'a list
                            val to_alist :
                              ?key_order:[ `Decreasing | `Increasing ] ->
                              'a t -> (node * 'a) list
                            val validate :
                              name:(node -> string) ->
                              'Base__.Validate.check ->
                              'a t Base__.Validate.check
                            val merge :
                              'a t ->
                              'b t ->
                              f:(key:node ->
                                 [ `Both of 'a * 'b
                                 | `Left of 'a
                                 | `Right of 'b ] -> 'c option) ->
                              'c t
                            val symmetric_diff :
                              'a t ->
                              'a t ->
                              data_equal:('-> '-> bool) ->
                              (node, 'a)
                              Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                              Base__.Sequence.t
                            val min_elt : 'a t -> (node * 'a) option
                            val min_elt_exn : 'a t -> node * 'a
                            val max_elt : 'a t -> (node * 'a) option
                            val max_elt_exn : 'a t -> node * 'a
                            val for_all : 'a t -> f:('-> bool) -> bool
                            val for_alli :
                              'a t -> f:(key:node -> data:'-> bool) -> bool
                            val exists : 'a t -> f:('-> bool) -> bool
                            val existsi :
                              'a t -> f:(key:node -> data:'-> bool) -> bool
                            val count : 'a t -> f:('-> bool) -> int
                            val counti :
                              'a t -> f:(key:node -> data:'-> bool) -> int
                            val split :
                              'a t ->
                              node -> 'a t * (node * 'a) option * 'a t
                            val append :
                              lower_part:'a t ->
                              upper_part:'a t ->
                              [ `Ok of 'a t | `Overlapping_key_ranges ]
                            val subrange :
                              'a t ->
                              lower_bound:node Base__.Maybe_bound.t ->
                              upper_bound:node Base__.Maybe_bound.t -> 'a t
                            val fold_range_inclusive :
                              'a t ->
                              min:node ->
                              max:node ->
                              init:'->
                              f:(key:node -> data:'-> '-> 'b) -> 'b
                            val range_to_alist :
                              'a t ->
                              min:node -> max:node -> (node * 'a) list
                            val closest_key :
                              'a t ->
                              [ `Greater_or_equal_to
                              | `Greater_than
                              | `Less_or_equal_to
                              | `Less_than ] -> node -> (node * 'a) option
                            val nth : 'a t -> int -> (node * 'a) option
                            val nth_exn : 'a t -> int -> node * 'a
                            val rank : 'a t -> node -> int option
                            val to_tree : 'a t -> 'a t
                            val to_sequence :
                              ?order:[ `Decreasing_key | `Increasing_key ] ->
                              ?keys_greater_or_equal_to:node ->
                              ?keys_less_or_equal_to:node ->
                              'a t -> (node * 'a) Base__.Sequence.t
                            val obs :
                              node Core_kernel__.Quickcheck.Observer.t ->
                              'Core_kernel__.Quickcheck.Observer.t ->
                              'v t Core_kernel__.Quickcheck.Observer.t
                            val shrinker :
                              node Core_kernel__.Quickcheck.Shrinker.t ->
                              'Core_kernel__.Quickcheck.Shrinker.t ->
                              'v t Core_kernel__.Quickcheck.Shrinker.t
                            module Provide_of_sexp :
                              functor
                                (K : sig
                                       val t_of_sexp : Sexplib.Sexp.t -> node
                                     end->
                                sig
                                  val t_of_sexp :
                                    (Sexplib.Sexp.t -> 'v_x__017_) ->
                                    Sexplib.Sexp.t -> 'v_x__017_ t
                                end
                            val t_of_sexp :
                              (Base__.Sexplib.Sexp.t -> 'a) ->
                              Base__.Sexplib.Sexp.t -> 'a t
                            val sexp_of_t :
                              ('-> Base__.Sexplib.Sexp.t) ->
                              'a t -> Base__.Sexplib.Sexp.t
                          end
                        type 'a t =
                            (node, 'a, comparator_witness)
                            Core_kernel__.Core_map_intf.Map.t
                        val compare :
                          ('-> '-> Core_kernel__.Import.int) ->
                          'a t -> 'a t -> Core_kernel__.Import.int
                        val empty : 'a t
                        val singleton : node -> '-> 'a t
                        val of_alist :
                          (node * 'a) list ->
                          [ `Duplicate_key of node | `Ok of 'a t ]
                        val of_alist_or_error :
                          (node * 'a) list -> 'a t Base__.Or_error.t
                        val of_alist_exn : (node * 'a) list -> 'a t
                        val of_alist_multi : (node * 'a) list -> 'a list t
                        val of_alist_fold :
                          (node * 'a) list ->
                          init:'-> f:('-> '-> 'b) -> 'b t
                        val of_alist_reduce :
                          (node * 'a) list -> f:('-> '-> 'a) -> 'a t
                        val of_sorted_array :
                          (node * 'a) array -> 'a t Base__.Or_error.t
                        val of_sorted_array_unchecked :
                          (node * 'a) array -> 'a t
                        val of_increasing_iterator_unchecked :
                          len:int -> f:(int -> node * 'a) -> 'a t
                        val of_iteri :
                          iteri:(f:(key:node -> data:'-> unit) -> unit) ->
                          [ `Duplicate_key of node | `Ok of 'v t ]
                        val of_tree : 'Tree.t -> 'a t
                        val of_hashtbl_exn :
                          (node, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                        val gen :
                          node Core_kernel__.Quickcheck.Generator.t ->
                          'Core_kernel__.Quickcheck.Generator.t ->
                          'a t Core_kernel__.Quickcheck.Generator.t
                        val invariants : 'a t -> bool
                        val is_empty : 'a t -> bool
                        val length : 'a t -> int
                        val add : 'a t -> key:node -> data:'-> 'a t
                        val add_multi :
                          'a list t -> key:node -> data:'-> 'a list t
                        val remove_multi : 'a list t -> node -> 'a list t
                        val change :
                          'a t -> node -> f:('a option -> 'a option) -> 'a t
                        val update :
                          'a t -> node -> f:('a option -> 'a) -> 'a t
                        val find : 'a t -> node -> 'a option
                        val find_exn : 'a t -> node -> 'a
                        val remove : 'a t -> node -> 'a t
                        val mem : 'a t -> node -> bool
                        val iter_keys : 'a t -> f:(node -> unit) -> unit
                        val iter : 'a t -> f:('-> unit) -> unit
                        val iteri :
                          'a t -> f:(key:node -> data:'-> unit) -> unit
                        val iter2 :
                          'a t ->
                          'b t ->
                          f:(key:node ->
                             data:[ `Both of 'a * 'b
                                  | `Left of 'a
                                  | `Right of 'b ] ->
                             unit) ->
                          unit
                        val map : 'a t -> f:('-> 'b) -> 'b t
                        val mapi :
                          'a t -> f:(key:node -> data:'-> 'b) -> 'b t
                        val fold :
                          'a t ->
                          init:'->
                          f:(key:node -> data:'-> '-> 'b) -> 'b
                        val fold_right :
                          'a t ->
                          init:'->
                          f:(key:node -> data:'-> '-> 'b) -> 'b
                        val fold2 :
                          'a t ->
                          'b t ->
                          init:'->
                          f:(key:node ->
                             data:[ `Both of 'a * 'b
                                  | `Left of 'a
                                  | `Right of 'b ] ->
                             '-> 'c) ->
                          'c
                        val filter_keys : 'a t -> f:(node -> bool) -> 'a t
                        val filter : 'a t -> f:('-> bool) -> 'a t
                        val filteri :
                          'a t -> f:(key:node -> data:'-> bool) -> 'a t
                        val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                        val filter_mapi :
                          'a t ->
                          f:(key:node -> data:'-> 'b option) -> 'b t
                        val partition_mapi :
                          'a t ->
                          f:(key:node ->
                             data:'-> [ `Fst of '| `Snd of 'c ]) ->
                          'b t * 'c t
                        val partition_map :
                          'a t ->
                          f:('-> [ `Fst of '| `Snd of 'c ]) ->
                          'b t * 'c t
                        val partitioni_tf :
                          'a t ->
                          f:(key:node -> data:'-> bool) -> 'a t * 'a t
                        val partition_tf :
                          'a t -> f:('-> bool) -> 'a t * 'a t
                        val compare_direct :
                          ('-> '-> int) -> 'a t -> 'a t -> int
                        val equal :
                          ('-> '-> bool) -> 'a t -> 'a t -> bool
                        val keys : 'a t -> node list
                        val data : 'a t -> 'a list
                        val to_alist :
                          ?key_order:[ `Decreasing | `Increasing ] ->
                          'a t -> (node * 'a) list
                        val validate :
                          name:(node -> string) ->
                          'Base__.Validate.check ->
                          'a t Base__.Validate.check
                        val merge :
                          'a t ->
                          'b t ->
                          f:(key:node ->
                             [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                             'c option) ->
                          'c t
                        val symmetric_diff :
                          'a t ->
                          'a t ->
                          data_equal:('-> '-> bool) ->
                          (node, 'a)
                          Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                          Base__.Sequence.t
                        val min_elt : 'a t -> (node * 'a) option
                        val min_elt_exn : 'a t -> node * 'a
                        val max_elt : 'a t -> (node * 'a) option
                        val max_elt_exn : 'a t -> node * 'a
                        val for_all : 'a t -> f:('-> bool) -> bool
                        val for_alli :
                          'a t -> f:(key:node -> data:'-> bool) -> bool
                        val exists : 'a t -> f:('-> bool) -> bool
                        val existsi :
                          'a t -> f:(key:node -> data:'-> bool) -> bool
                        val count : 'a t -> f:('-> bool) -> int
                        val counti :
                          'a t -> f:(key:node -> data:'-> bool) -> int
                        val split :
                          'a t -> node -> 'a t * (node * 'a) option * 'a t
                        val append :
                          lower_part:'a t ->
                          upper_part:'a t ->
                          [ `Ok of 'a t | `Overlapping_key_ranges ]
                        val subrange :
                          'a t ->
                          lower_bound:node Base__.Maybe_bound.t ->
                          upper_bound:node Base__.Maybe_bound.t -> 'a t
                        val fold_range_inclusive :
                          'a t ->
                          min:node ->
                          max:node ->
                          init:'->
                          f:(key:node -> data:'-> '-> 'b) -> 'b
                        val range_to_alist :
                          'a t -> min:node -> max:node -> (node * 'a) list
                        val closest_key :
                          'a t ->
                          [ `Greater_or_equal_to
                          | `Greater_than
                          | `Less_or_equal_to
                          | `Less_than ] -> node -> (node * 'a) option
                        val nth : 'a t -> int -> (node * 'a) option
                        val nth_exn : 'a t -> int -> node * 'a
                        val rank : 'a t -> node -> int option
                        val to_tree : 'a t -> 'Tree.t
                        val to_sequence :
                          ?order:[ `Decreasing_key | `Increasing_key ] ->
                          ?keys_greater_or_equal_to:node ->
                          ?keys_less_or_equal_to:node ->
                          'a t -> (node * 'a) Base__.Sequence.t
                        val obs :
                          node Core_kernel__.Quickcheck.Observer.t ->
                          'Core_kernel__.Quickcheck.Observer.t ->
                          'v t Core_kernel__.Quickcheck.Observer.t
                        val shrinker :
                          node Core_kernel__.Quickcheck.Shrinker.t ->
                          'Core_kernel__.Quickcheck.Shrinker.t ->
                          'v t Core_kernel__.Quickcheck.Shrinker.t
                        module Provide_of_sexp :
                          functor
                            (Key : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> node
                                   end->
                            sig
                              val t_of_sexp :
                                (Sexplib.Sexp.t -> 'v_x__018_) ->
                                Sexplib.Sexp.t -> 'v_x__018_ t
                            end
                        module Provide_bin_io :
                          functor
                            (Key : sig
                                     val bin_t : node Bin_prot.Type_class.t
                                     val bin_read_t :
                                       node Bin_prot.Read.reader
                                     val __bin_read_t__ :
                                       (Core_kernel__.Import.int -> node)
                                       Bin_prot.Read.reader
                                     val bin_reader_t :
                                       node Bin_prot.Type_class.reader
                                     val bin_size_t :
                                       node Bin_prot.Size.sizer
                                     val bin_write_t :
                                       node Bin_prot.Write.writer
                                     val bin_writer_t :
                                       node Bin_prot.Type_class.writer
                                     val bin_shape_t : Bin_prot.Shape.t
                                   end->
                            sig
                              val bin_shape_t :
                                Bin_prot.Shape.t -> Bin_prot.Shape.t
                              val bin_size_t :
                                ('a, 'a t) Bin_prot.Size.sizer1
                              val bin_write_t :
                                ('a, 'a t) Bin_prot.Write.writer1
                              val bin_read_t :
                                ('a, 'a t) Bin_prot.Read.reader1
                              val __bin_read_t__ :
                                ('a, int -> 'a t) Bin_prot.Read.reader1
                              val bin_writer_t :
                                ('a, 'a t) Bin_prot.Type_class.S1.writer
                              val bin_reader_t :
                                ('a, 'a t) Bin_prot.Type_class.S1.reader
                              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                            end
                        module Provide_hash :
                          functor
                            (Key : sig
                                     val hash_fold_t :
                                       Base__.Hash.state ->
                                       node -> Base__.Hash.state
                                   end->
                            sig
                              val hash_fold_t :
                                (Ppx_hash_lib.Std.Hash.state ->
                                 '-> Ppx_hash_lib.Std.Hash.state) ->
                                Ppx_hash_lib.Std.Hash.state ->
                                'a t -> Ppx_hash_lib.Std.Hash.state
                            end
                        val t_of_sexp :
                          (Base__.Sexplib.Sexp.t -> 'a) ->
                          Base__.Sexplib.Sexp.t -> 'a t
                        val sexp_of_t :
                          ('-> Base__.Sexplib.Sexp.t) ->
                          'a t -> Base__.Sexplib.Sexp.t
                      end
                    module Set :
                      sig
                        module Elt :
                          sig
                            type t = node
                            val t_of_sexp : Sexplib.Sexp.t -> t
                            val sexp_of_t : t -> Sexplib.Sexp.t
                            type comparator_witness =
                                Map.Key.comparator_witness
                            val comparator :
                              (t, comparator_witness)
                              Core_kernel__.Comparator.comparator
                          end
                        module Tree :
                          sig
                            type t =
                                (node, comparator_witness)
                                Core_kernel__.Core_set_intf.Tree.t
                            val compare : t -> t -> Core_kernel__.Import.int
                            val length : t -> int
                            val is_empty : t -> bool
                            val iter : t -> f:(node -> unit) -> unit
                            val fold :
                              t ->
                              init:'accum ->
                              f:('accum -> node -> 'accum) -> 'accum
                            val fold_result :
                              t ->
                              init:'accum ->
                              f:('accum ->
                                 node -> ('accum, 'e) Base__.Result.t) ->
                              ('accum, 'e) Base__.Result.t
                            val exists : t -> f:(node -> bool) -> bool
                            val for_all : t -> f:(node -> bool) -> bool
                            val count : t -> f:(node -> bool) -> int
                            val sum :
                              (module Base__.Commutative_group.S with type t = 'sum) ->
                              t -> f:(node -> 'sum) -> 'sum
                            val find : t -> f:(node -> bool) -> node option
                            val find_map :
                              t -> f:(node -> 'a option) -> 'a option
                            val to_list : t -> node list
                            val to_array : t -> node array
                            val invariants : t -> bool
                            val mem : t -> node -> bool
                            val add : t -> node -> t
                            val remove : t -> node -> t
                            val union : t -> t -> t
                            val inter : t -> t -> t
                            val diff : t -> t -> t
                            val symmetric_diff :
                              t ->
                              t ->
                              (node, node) Base__.Either.t Base__.Sequence.t
                            val compare_direct : t -> t -> int
                            val equal : t -> t -> bool
                            val is_subset : t -> of_:t -> bool
                            val subset : t -> t -> bool
                            val fold_until :
                              t ->
                              init:'->
                              f:('->
                                 node ->
                                 ('b, 'stop)
                                 Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                              ('b, 'stop)
                              Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                            val fold_right :
                              t -> init:'-> f:(node -> '-> 'b) -> 'b
                            val iter2 :
                              t ->
                              t ->
                              f:([ `Both of node * node
                                 | `Left of node
                                 | `Right of node ] -> unit) ->
                              unit
                            val filter : t -> f:(node -> bool) -> t
                            val partition_tf : t -> f:(node -> bool) -> t * t
                            val elements : t -> node list
                            val min_elt : t -> node option
                            val min_elt_exn : t -> node
                            val max_elt : t -> node option
                            val max_elt_exn : t -> node
                            val choose : t -> node option
                            val choose_exn : t -> node
                            val split : t -> node -> t * node option * t
                            val group_by :
                              t -> equiv:(node -> node -> bool) -> t list
                            val find_exn : t -> f:(node -> bool) -> node
                            val find_index : t -> int -> node option
                            val nth : t -> int -> node option
                            val remove_index : t -> int -> t
                            val to_tree : t -> t
                            val to_sequence :
                              ?order:[ `Decreasing | `Increasing ] ->
                              ?greater_or_equal_to:node ->
                              ?less_or_equal_to:node ->
                              t -> node Base__.Sequence.t
                            val merge_to_sequence :
                              ?order:[ `Decreasing | `Increasing ] ->
                              ?greater_or_equal_to:node ->
                              ?less_or_equal_to:node ->
                              t ->
                              t ->
                              (node, node)
                              Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                              Base__.Sequence.t
                            val to_map :
                              t ->
                              f:(node -> 'data) ->
                              (node, 'data, comparator_witness)
                              Core_kernel__.Core_set_intf.Map.t
                            val obs :
                              node Core_kernel__.Quickcheck.Observer.t ->
                              t Core_kernel__.Quickcheck.Observer.t
                            val shrinker :
                              node Core_kernel__.Quickcheck.Shrinker.t ->
                              t Core_kernel__.Quickcheck.Shrinker.t
                            val empty : t
                            val singleton : node -> t
                            val union_list : t list -> t
                            val of_list : node list -> t
                            val of_array : node array -> t
                            val of_sorted_array :
                              node array -> t Base__.Or_error.t
                            val of_sorted_array_unchecked : node array -> t
                            val of_increasing_iterator_unchecked :
                              len:int -> f:(int -> node) -> t
                            val stable_dedup_list : node list -> node list
                            val map :
                              ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                              f:('-> node) -> t
                            val filter_map :
                              ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                              f:('-> node option) -> t
                            val of_tree : t -> t
                            val of_hash_set :
                              node Core_kernel__.Hash_set.t -> t
                            val of_hashtbl_keys :
                              (node, 'a) Core_kernel__.Core_hashtbl.t -> t
                            val of_map_keys :
                              (node, 'a, comparator_witness)
                              Core_kernel__.Core_set_intf.Map.t -> t
                            val gen :
                              node Core_kernel__.Quickcheck.Generator.t ->
                              t Core_kernel__.Quickcheck.Generator.t
                            module Provide_of_sexp :
                              functor
                                (Elt : sig
                                         val t_of_sexp :
                                           Sexplib.Sexp.t -> node
                                       end->
                                sig val t_of_sexp : Sexplib.Sexp.t -> t end
                            val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                            val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                          end
                        type t = (node, comparator_witness) Base.Set.t
                        val compare : t -> t -> Core_kernel__.Import.int
                        val length : t -> int
                        val is_empty : t -> bool
                        val iter : t -> f:(node -> unit) -> unit
                        val fold :
                          t ->
                          init:'accum ->
                          f:('accum -> node -> 'accum) -> 'accum
                        val fold_result :
                          t ->
                          init:'accum ->
                          f:('accum -> node -> ('accum, 'e) Base__.Result.t) ->
                          ('accum, 'e) Base__.Result.t
                        val exists : t -> f:(node -> bool) -> bool
                        val for_all : t -> f:(node -> bool) -> bool
                        val count : t -> f:(node -> bool) -> int
                        val sum :
                          (module Base__.Commutative_group.S with type t = 'sum) ->
                          t -> f:(node -> 'sum) -> 'sum
                        val find : t -> f:(node -> bool) -> node option
                        val find_map :
                          t -> f:(node -> 'a option) -> 'a option
                        val to_list : t -> node list
                        val to_array : t -> node array
                        val invariants : t -> bool
                        val mem : t -> node -> bool
                        val add : t -> node -> t
                        val remove : t -> node -> t
                        val union : t -> t -> t
                        val inter : t -> t -> t
                        val diff : t -> t -> t
                        val symmetric_diff :
                          t ->
                          t -> (node, node) Base__.Either.t Base__.Sequence.t
                        val compare_direct : t -> t -> int
                        val equal : t -> t -> bool
                        val is_subset : t -> of_:t -> bool
                        val subset : t -> t -> bool
                        val fold_until :
                          t ->
                          init:'->
                          f:('->
                             node ->
                             ('b, 'stop)
                             Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                          ('b, 'stop)
                          Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                        val fold_right :
                          t -> init:'-> f:(node -> '-> 'b) -> 'b
                        val iter2 :
                          t ->
                          t ->
                          f:([ `Both of node * node
                             | `Left of node
                             | `Right of node ] -> unit) ->
                          unit
                        val filter : t -> f:(node -> bool) -> t
                        val partition_tf : t -> f:(node -> bool) -> t * t
                        val elements : t -> node list
                        val min_elt : t -> node option
                        val min_elt_exn : t -> node
                        val max_elt : t -> node option
                        val max_elt_exn : t -> node
                        val choose : t -> node option
                        val choose_exn : t -> node
                        val split : t -> node -> t * node option * t
                        val group_by :
                          t -> equiv:(node -> node -> bool) -> t list
                        val find_exn : t -> f:(node -> bool) -> node
                        val find_index : t -> int -> node option
                        val nth : t -> int -> node option
                        val remove_index : t -> int -> t
                        val to_tree : t -> Tree.t
                        val to_sequence :
                          ?order:[ `Decreasing | `Increasing ] ->
                          ?greater_or_equal_to:node ->
                          ?less_or_equal_to:node ->
                          t -> node Base__.Sequence.t
                        val merge_to_sequence :
                          ?order:[ `Decreasing | `Increasing ] ->
                          ?greater_or_equal_to:node ->
                          ?less_or_equal_to:node ->
                          t ->
                          t ->
                          (node, node)
                          Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                          Base__.Sequence.t
                        val to_map :
                          t ->
                          f:(node -> 'data) ->
                          (node, 'data, comparator_witness)
                          Core_kernel__.Core_set_intf.Map.t
                        val obs :
                          node Core_kernel__.Quickcheck.Observer.t ->
                          t Core_kernel__.Quickcheck.Observer.t
                        val shrinker :
                          node Core_kernel__.Quickcheck.Shrinker.t ->
                          t Core_kernel__.Quickcheck.Shrinker.t
                        val empty : t
                        val singleton : node -> t
                        val union_list : t list -> t
                        val of_list : node list -> t
                        val of_array : node array -> t
                        val of_sorted_array :
                          node array -> t Base__.Or_error.t
                        val of_sorted_array_unchecked : node array -> t
                        val of_increasing_iterator_unchecked :
                          len:int -> f:(int -> node) -> t
                        val stable_dedup_list : node list -> node list
                        val map : ('a, 'b) Base.Set.t -> f:('-> node) -> t
                        val filter_map :
                          ('a, 'b) Base.Set.t -> f:('-> node option) -> t
                        val of_tree : Tree.t -> t
                        val of_hash_set : node Core_kernel__.Hash_set.t -> t
                        val of_hashtbl_keys :
                          (node, 'a) Core_kernel__.Core_hashtbl.t -> t
                        val of_map_keys :
                          (node, 'a, comparator_witness)
                          Core_kernel__.Core_set_intf.Map.t -> t
                        val gen :
                          node Core_kernel__.Quickcheck.Generator.t ->
                          t Core_kernel__.Quickcheck.Generator.t
                        module Provide_of_sexp :
                          functor
                            (Elt : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> node
                                   end->
                            sig val t_of_sexp : Sexplib.Sexp.t -> t end
                        module Provide_bin_io :
                          functor
                            (Elt : sig
                                     val bin_t : node Bin_prot.Type_class.t
                                     val bin_read_t :
                                       node Bin_prot.Read.reader
                                     val __bin_read_t__ :
                                       (Core_kernel__.Import.int -> node)
                                       Bin_prot.Read.reader
                                     val bin_reader_t :
                                       node Bin_prot.Type_class.reader
                                     val bin_size_t :
                                       node Bin_prot.Size.sizer
                                     val bin_write_t :
                                       node Bin_prot.Write.writer
                                     val bin_writer_t :
                                       node Bin_prot.Type_class.writer
                                     val bin_shape_t : Bin_prot.Shape.t
                                   end->
                            sig
                              val bin_size_t : t Bin_prot.Size.sizer
                              val bin_write_t : t Bin_prot.Write.writer
                              val bin_read_t : t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                (int -> t) Bin_prot.Read.reader
                              val bin_shape_t : Bin_prot.Shape.t
                              val bin_writer_t : t Bin_prot.Type_class.writer
                              val bin_reader_t : t Bin_prot.Type_class.reader
                              val bin_t : t Bin_prot.Type_class.t
                            end
                        module Provide_hash :
                          functor
                            (Elt : sig
                                     val hash_fold_t :
                                       Base__.Hash.state ->
                                       node -> Base__.Hash.state
                                   end->
                            sig
                              val hash_fold_t :
                                Ppx_hash_lib.Std.Hash.state ->
                                t -> Ppx_hash_lib.Std.Hash.state
                              val hash :
                                t -> Ppx_hash_lib.Std.Hash.hash_value
                            end
                        val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                        val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                      end
                    val hash : t -> Core_kernel__.Import.int
                    val compare : t -> t -> Core_kernel__.Import.int
                    val hashable :
                      t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
                    module Table :
                      sig
                        type key = t
                        type ('a, 'b) hashtbl = ('a, 'b) Equiv.Table.hashtbl
                        type 'b t = (key, 'b) hashtbl
                        val sexp_of_t :
                          ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                        type ('a, 'b) t_ = 'b t
                        type 'a key_ = key
                        val hashable :
                          key Core_kernel__.Core_hashtbl_intf.Hashable.t
                        val invariant :
                          'Base__.Invariant_intf.inv ->
                          'a t Base__.Invariant_intf.inv
                        val create :
                          (key, 'b, unit -> 'b t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist :
                          (key, 'b,
                           (key * 'b) list ->
                           [ `Duplicate_key of key | `Ok of 'b t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_report_all_dups :
                          (key, 'b,
                           (key * 'b) list ->
                           [ `Duplicate_keys of key list | `Ok of 'b t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_or_error :
                          (key, 'b,
                           (key * 'b) list -> 'b t Base__.Or_error.t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_exn :
                          (key, 'b, (key * 'b) list -> 'b t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_multi :
                          (key, 'b list, (key * 'b) list -> 'b list t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_mapped :
                          (key, 'b,
                           get_key:('-> key) ->
                           get_data:('-> 'b) ->
                           'r list ->
                           [ `Duplicate_keys of key list | `Ok of 'b t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_with_key :
                          (key, 'r,
                           get_key:('-> key) ->
                           'r list ->
                           [ `Duplicate_keys of key list | `Ok of 'r t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_with_key_or_error :
                          (key, 'r,
                           get_key:('-> key) ->
                           'r list -> 'r t Base__.Or_error.t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_with_key_exn :
                          (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val group :
                          (key, 'b,
                           get_key:('-> key) ->
                           get_data:('-> 'b) ->
                           combine:('-> '-> 'b) -> 'r list -> 'b t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                        val clear : 'a t -> unit
                        val copy : 'b t -> 'b t
                        val fold :
                          'b t ->
                          init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                        val iter_keys : 'a t -> f:(key -> unit) -> unit
                        val iter : 'b t -> f:('-> unit) -> unit
                        val iteri :
                          'b t -> f:(key:key -> data:'-> unit) -> unit
                        val iter_vals : 'b t -> f:('-> unit) -> unit
                        val existsi :
                          'b t -> f:(key:key -> data:'-> bool) -> bool
                        val exists : 'b t -> f:('-> bool) -> bool
                        val for_alli :
                          'b t -> f:(key:key -> data:'-> bool) -> bool
                        val for_all : 'b t -> f:('-> bool) -> bool
                        val counti :
                          'b t -> f:(key:key -> data:'-> bool) -> int
                        val count : 'b t -> f:('-> bool) -> int
                        val length : 'a t -> int
                        val is_empty : 'a t -> bool
                        val mem : 'a t -> key -> bool
                        val remove : 'a t -> key -> unit
                        val replace : 'b t -> key:key -> data:'-> unit
                        val set : 'b t -> key:key -> data:'-> unit
                        val add :
                          'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                        val add_or_error :
                          'b t ->
                          key:key -> data:'-> unit Base__.Or_error.t
                        val add_exn : 'b t -> key:key -> data:'-> unit
                        val change :
                          'b t -> key -> f:('b option -> 'b option) -> unit
                        val update :
                          'b t -> key -> f:('b option -> 'b) -> unit
                        val add_multi :
                          'b list t -> key:key -> data:'-> unit
                        val remove_multi : 'a list t -> key -> unit
                        val map : 'b t -> f:('-> 'c) -> 'c t
                        val mapi :
                          'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                        val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                        val filter_mapi :
                          'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                        val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                        val filter : 'b t -> f:('-> bool) -> 'b t
                        val filteri :
                          'b t -> f:(key:key -> data:'-> bool) -> 'b t
                        val partition_map :
                          'b t ->
                          f:('-> [ `Fst of '| `Snd of 'd ]) ->
                          'c t * 'd t
                        val partition_mapi :
                          'b t ->
                          f:(key:key ->
                             data:'-> [ `Fst of '| `Snd of 'd ]) ->
                          'c t * 'd t
                        val partition_tf :
                          'b t -> f:('-> bool) -> 'b t * 'b t
                        val partitioni_tf :
                          'b t ->
                          f:(key:key -> data:'-> bool) -> 'b t * 'b t
                        val find_or_add :
                          'b t -> key -> default:(unit -> 'b) -> 'b
                        val find : 'b t -> key -> 'b option
                        val find_exn : 'b t -> key -> 'b
                        val find_and_call :
                          'b t ->
                          key ->
                          if_found:('-> 'c) ->
                          if_not_found:(key -> 'c) -> 'c
                        val find_and_remove : 'b t -> key -> 'b option
                        val merge :
                          'a t ->
                          'b t ->
                          f:(key:key ->
                             [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                             'c option) ->
                          'c t
                        type 'a merge_into_action = Remove | Set_to of 'a
                        val merge_into :
                          src:'a t ->
                          dst:'b t ->
                          f:(key:key ->
                             '-> 'b option -> 'b merge_into_action) ->
                          unit
                        val keys : 'a t -> key list
                        val data : 'b t -> 'b list
                        val filter_keys_inplace :
                          'a t -> f:(key -> bool) -> unit
                        val filter_inplace : 'b t -> f:('-> bool) -> unit
                        val filteri_inplace :
                          'b t -> f:(key:key -> data:'-> bool) -> unit
                        val map_inplace : 'b t -> f:('-> 'b) -> unit
                        val mapi_inplace :
                          'b t -> f:(key:key -> data:'-> 'b) -> unit
                        val filter_map_inplace :
                          'b t -> f:('-> 'b option) -> unit
                        val filter_mapi_inplace :
                          'b t -> f:(key:key -> data:'-> 'b option) -> unit
                        val replace_all : 'b t -> f:('-> 'b) -> unit
                        val replace_alli :
                          'b t -> f:(key:key -> data:'-> 'b) -> unit
                        val filter_replace_all :
                          'b t -> f:('-> 'b option) -> unit
                        val filter_replace_alli :
                          'b t -> f:(key:key -> data:'-> 'b option) -> unit
                        val equal :
                          'b t -> 'b t -> ('-> '-> bool) -> bool
                        val similar :
                          'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                        val to_alist : 'b t -> (key * 'b) list
                        val validate :
                          name:(key -> string) ->
                          'Base__.Validate.check ->
                          'b t Base__.Validate.check
                        val incr :
                          ?by:int ->
                          ?remove_if_zero:bool -> int t -> key -> unit
                        val decr :
                          ?by:int ->
                          ?remove_if_zero:bool -> int t -> key -> unit
                        module Provide_of_sexp :
                          functor
                            (Key : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> key
                                   end->
                            sig
                              val t_of_sexp :
                                (Sexplib.Sexp.t -> 'v_x__001_) ->
                                Sexplib.Sexp.t -> 'v_x__001_ t
                            end
                        module Provide_bin_io :
                          functor
                            (Key : sig
                                     val bin_t : key Bin_prot.Type_class.t
                                     val bin_read_t :
                                       key Bin_prot.Read.reader
                                     val __bin_read_t__ :
                                       (Core_kernel__.Import.int -> key)
                                       Bin_prot.Read.reader
                                     val bin_reader_t :
                                       key Bin_prot.Type_class.reader
                                     val bin_size_t : key Bin_prot.Size.sizer
                                     val bin_write_t :
                                       key Bin_prot.Write.writer
                                     val bin_writer_t :
                                       key Bin_prot.Type_class.writer
                                     val bin_shape_t : Bin_prot.Shape.t
                                   end->
                            sig
                              val bin_t :
                                'Bin_prot.Type_class.t ->
                                'a t Bin_prot.Type_class.t
                              val bin_read_t :
                                'Bin_prot.Read.reader ->
                                'a t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                'Bin_prot.Read.reader ->
                                (Core_kernel__.Import.int -> 'a t)
                                Bin_prot.Read.reader
                              val bin_reader_t :
                                'Bin_prot.Type_class.reader ->
                                'a t Bin_prot.Type_class.reader
                              val bin_size_t :
                                'Bin_prot.Size.sizer ->
                                'a t Bin_prot.Size.sizer
                              val bin_write_t :
                                'Bin_prot.Write.writer ->
                                'a t Bin_prot.Write.writer
                              val bin_writer_t :
                                'Bin_prot.Type_class.writer ->
                                'a t Bin_prot.Type_class.writer
                              val bin_shape_t :
                                Bin_prot.Shape.t -> Bin_prot.Shape.t
                            end
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__002_) ->
                          Sexplib.Sexp.t -> 'v_x__002_ t
                      end
                    module Hash_set :
                      sig
                        type elt = t
                        type t = elt Core_kernel__.Hash_set.t
                        val sexp_of_t : t -> Sexplib.Sexp.t
                        type 'a t_ = t
                        type 'a elt_ = elt
                        val create :
                          ('a, unit -> t)
                          Core_kernel__.Hash_set_intf.create_options_without_hashable
                        val of_list :
                          ('a, elt list -> t)
                          Core_kernel__.Hash_set_intf.create_options_without_hashable
                        module Provide_of_sexp :
                          functor
                            (X : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> elt
                                 end->
                            sig val t_of_sexp : Sexplib.Sexp.t -> t end
                        module Provide_bin_io :
                          functor
                            (X : sig
                                   val bin_t : elt Bin_prot.Type_class.t
                                   val bin_read_t : elt Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> elt)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     elt Bin_prot.Type_class.reader
                                   val bin_size_t : elt Bin_prot.Size.sizer
                                   val bin_write_t :
                                     elt Bin_prot.Write.writer
                                   val bin_writer_t :
                                     elt Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                            sig
                              val bin_t : t Bin_prot.Type_class.t
                              val bin_read_t : t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                (Core_kernel__.Import.int -> t)
                                Bin_prot.Read.reader
                              val bin_reader_t : t Bin_prot.Type_class.reader
                              val bin_size_t : t Bin_prot.Size.sizer
                              val bin_write_t : t Bin_prot.Write.writer
                              val bin_writer_t : t Bin_prot.Type_class.writer
                              val bin_shape_t : Bin_prot.Shape.t
                            end
                        val t_of_sexp : Sexplib.Sexp.t -> t
                      end
                    module Hash_queue :
                      sig
                        module Key :
                          sig
                            type t = node
                            val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                            val compare : t -> t -> int
                            val hash : t -> int
                          end
                        type 'a t
                        val sexp_of_t :
                          ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                        val length : 'a t -> int
                        val is_empty : 'a t -> bool
                        val iter : 'a t -> f:('-> unit) -> unit
                        val fold :
                          'a t ->
                          init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                        val fold_result :
                          'a t ->
                          init:'accum ->
                          f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                          ('accum, 'e) Base__.Result.t
                        val fold_until :
                          'a t ->
                          init:'accum ->
                          f:('accum ->
                             '->
                             ('accum, 'stop)
                             Base.Container_intf.Continue_or_stop.t) ->
                          ('accum, 'stop)
                          Base.Container_intf.Finished_or_stopped_early.t
                        val exists : 'a t -> f:('-> bool) -> bool
                        val for_all : 'a t -> f:('-> bool) -> bool
                        val count : 'a t -> f:('-> bool) -> int
                        val sum :
                          (module Base__.Commutative_group.S with type t = 'sum) ->
                          'a t -> f:('-> 'sum) -> 'sum
                        val find : 'a t -> f:('-> bool) -> 'a option
                        val find_map :
                          'a t -> f:('-> 'b option) -> 'b option
                        val to_list : 'a t -> 'a list
                        val to_array : 'a t -> 'a array
                        val min_elt :
                          'a t -> cmp:('-> '-> int) -> 'a option
                        val max_elt :
                          'a t -> cmp:('-> '-> int) -> 'a option
                        val invariant : 'a t -> Core_kernel__.Import.unit
                        val create :
                          ?growth_allowed:Core_kernel__.Import.bool ->
                          ?size:Core_kernel__.Import.int ->
                          Core_kernel__.Import.unit -> 'a t
                        val clear : 'a t -> Core_kernel__.Import.unit
                        val mem : 'a t -> node -> Core_kernel__.Import.bool
                        val lookup :
                          'a t -> node -> 'Core_kernel__.Import.option
                        val lookup_exn : 'a t -> node -> 'a
                        val enqueue :
                          'a t ->
                          node -> '-> [ `Key_already_present | `Ok ]
                        val enqueue_exn :
                          'a t -> node -> '-> Core_kernel__.Import.unit
                        val lookup_and_move_to_back :
                          'a t -> node -> 'Core_kernel__.Import.option
                        val lookup_and_move_to_back_exn : 'a t -> node -> 'a
                        val first : 'a t -> 'Core_kernel__.Import.option
                        val first_with_key :
                          'a t -> (node * 'a) Core_kernel__.Import.option
                        val keys : 'a t -> node Core_kernel__.Import.list
                        val dequeue : 'a t -> 'Core_kernel__.Import.option
                        val dequeue_exn : 'a t -> 'a
                        val dequeue_with_key :
                          'a t -> (node * 'a) Core_kernel__.Import.option
                        val dequeue_with_key_exn : 'a t -> node * 'a
                        val dequeue_all :
                          'a t ->
                          f:('-> Core_kernel__.Import.unit) ->
                          Core_kernel__.Import.unit
                        val remove : 'a t -> node -> [ `No_such_key | `Ok ]
                        val remove_exn :
                          'a t -> node -> Core_kernel__.Import.unit
                        val replace :
                          'a t -> node -> '-> [ `No_such_key | `Ok ]
                        val replace_exn :
                          'a t -> node -> '-> Core_kernel__.Import.unit
                        val iteri :
                          'a t ->
                          f:(key:node -> data:'-> Core_kernel__.Import.unit) ->
                          Core_kernel__.Import.unit
                        val foldi :
                          'a t ->
                          init:'->
                          f:('-> key:node -> data:'-> 'b) -> 'b
                      end
                  end
                module Edge :
                  sig
                    type t = edge
                    type node = Node.t
                    type graph = Node.graph
                    type label = G.E.label
                    val create : node -> node -> label -> t
                    val label : t -> label
                    val src : t -> node
                    val dst : t -> node
                    val mem : t -> graph -> bool
                    val insert : t -> graph -> graph
                    val update : t -> label -> graph -> graph
                    val remove : t -> graph -> graph
                    val ( >= ) : t -> t -> bool
                    val ( <= ) : t -> t -> bool
                    val ( = ) : t -> t -> bool
                    val ( > ) : t -> t -> bool
                    val ( < ) : t -> t -> bool
                    val ( <> ) : t -> t -> bool
                    val equal : t -> t -> bool
                    val min : t -> t -> t
                    val max : t -> t -> t
                    val ascending : t -> t -> int
                    val descending : t -> t -> int
                    val between : t -> low:t -> high:t -> bool
                    val clamp_exn : t -> min:t -> max:t -> t
                    val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
                    type comparator_witness
                    val comparator :
                      (t, comparator_witness) Base__.Comparator.comparator
                    val validate_lbound :
                      min:t Base__.Maybe_bound.t -> t Base__.Validate.check
                    val validate_ubound :
                      max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                    val validate_bound :
                      min:t Base__.Maybe_bound.t ->
                      max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                    module Replace_polymorphic_compare :
                      sig
                        val ( >= ) : t -> t -> bool
                        val ( <= ) : t -> t -> bool
                        val ( = ) : t -> t -> bool
                        val ( > ) : t -> t -> bool
                        val ( < ) : t -> t -> bool
                        val ( <> ) : t -> t -> bool
                        val equal : t -> t -> bool
                        val compare : t -> t -> int
                        val min : t -> t -> t
                        val max : t -> t -> t
                      end
                    module Map :
                      sig
                        module Key :
                          sig
                            type t = edge
                            val t_of_sexp : Sexplib.Sexp.t -> t
                            val sexp_of_t : t -> Sexplib.Sexp.t
                            type comparator_witness = comparator_witness
                            val comparator :
                              (t, comparator_witness)
                              Core_kernel__.Comparator.comparator
                          end
                        module Tree :
                          sig
                            type 'a t =
                                (edge, 'a, comparator_witness)
                                Core_kernel__.Core_map_intf.Tree.t
                            val empty : 'a t
                            val singleton : edge -> '-> 'a t
                            val of_alist :
                              (edge * 'a) list ->
                              [ `Duplicate_key of edge | `Ok of 'a t ]
                            val of_alist_or_error :
                              (edge * 'a) list -> 'a t Base__.Or_error.t
                            val of_alist_exn : (edge * 'a) list -> 'a t
                            val of_alist_multi :
                              (edge * 'a) list -> 'a list t
                            val of_alist_fold :
                              (edge * 'a) list ->
                              init:'-> f:('-> '-> 'b) -> 'b t
                            val of_alist_reduce :
                              (edge * 'a) list -> f:('-> '-> 'a) -> 'a t
                            val of_sorted_array :
                              (edge * 'a) array -> 'a t Base__.Or_error.t
                            val of_sorted_array_unchecked :
                              (edge * 'a) array -> 'a t
                            val of_increasing_iterator_unchecked :
                              len:int -> f:(int -> edge * 'a) -> 'a t
                            val of_iteri :
                              iteri:(f:(key:edge -> data:'-> unit) -> unit) ->
                              [ `Duplicate_key of edge | `Ok of 'v t ]
                            val of_tree : 'a t -> 'a t
                            val of_hashtbl_exn :
                              (edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                            val gen :
                              edge Core_kernel__.Quickcheck.Generator.t ->
                              'Core_kernel__.Quickcheck.Generator.t ->
                              'a t Core_kernel__.Quickcheck.Generator.t
                            val invariants : 'a t -> bool
                            val is_empty : 'a t -> bool
                            val length : 'a t -> int
                            val add : 'a t -> key:edge -> data:'-> 'a t
                            val add_multi :
                              'a list t -> key:edge -> data:'-> 'a list t
                            val remove_multi : 'a list t -> edge -> 'a list t
                            val change :
                              'a t ->
                              edge -> f:('a option -> 'a option) -> 'a t
                            val update :
                              'a t -> edge -> f:('a option -> 'a) -> 'a t
                            val find : 'a t -> edge -> 'a option
                            val find_exn : 'a t -> edge -> 'a
                            val remove : 'a t -> edge -> 'a t
                            val mem : 'a t -> edge -> bool
                            val iter_keys : 'a t -> f:(edge -> unit) -> unit
                            val iter : 'a t -> f:('-> unit) -> unit
                            val iteri :
                              'a t -> f:(key:edge -> data:'-> unit) -> unit
                            val iter2 :
                              'a t ->
                              'b t ->
                              f:(key:edge ->
                                 data:[ `Both of 'a * 'b
                                      | `Left of 'a
                                      | `Right of 'b ] ->
                                 unit) ->
                              unit
                            val map : 'a t -> f:('-> 'b) -> 'b t
                            val mapi :
                              'a t -> f:(key:edge -> data:'-> 'b) -> 'b t
                            val fold :
                              'a t ->
                              init:'->
                              f:(key:edge -> data:'-> '-> 'b) -> 'b
                            val fold_right :
                              'a t ->
                              init:'->
                              f:(key:edge -> data:'-> '-> 'b) -> 'b
                            val fold2 :
                              'a t ->
                              'b t ->
                              init:'->
                              f:(key:edge ->
                                 data:[ `Both of 'a * 'b
                                      | `Left of 'a
                                      | `Right of 'b ] ->
                                 '-> 'c) ->
                              'c
                            val filter_keys :
                              'a t -> f:(edge -> bool) -> 'a t
                            val filter : 'a t -> f:('-> bool) -> 'a t
                            val filteri :
                              'a t -> f:(key:edge -> data:'-> bool) -> 'a t
                            val filter_map :
                              'a t -> f:('-> 'b option) -> 'b t
                            val filter_mapi :
                              'a t ->
                              f:(key:edge -> data:'-> 'b option) -> 'b t
                            val partition_mapi :
                              'a t ->
                              f:(key:edge ->
                                 data:'-> [ `Fst of '| `Snd of 'c ]) ->
                              'b t * 'c t
                            val partition_map :
                              'a t ->
                              f:('-> [ `Fst of '| `Snd of 'c ]) ->
                              'b t * 'c t
                            val partitioni_tf :
                              'a t ->
                              f:(key:edge -> data:'-> bool) -> 'a t * 'a t
                            val partition_tf :
                              'a t -> f:('-> bool) -> 'a t * 'a t
                            val compare_direct :
                              ('-> '-> int) -> 'a t -> 'a t -> int
                            val equal :
                              ('-> '-> bool) -> 'a t -> 'a t -> bool
                            val keys : 'a t -> edge list
                            val data : 'a t -> 'a list
                            val to_alist :
                              ?key_order:[ `Decreasing | `Increasing ] ->
                              'a t -> (edge * 'a) list
                            val validate :
                              name:(edge -> string) ->
                              'Base__.Validate.check ->
                              'a t Base__.Validate.check
                            val merge :
                              'a t ->
                              'b t ->
                              f:(key:edge ->
                                 [ `Both of 'a * 'b
                                 | `Left of 'a
                                 | `Right of 'b ] -> 'c option) ->
                              'c t
                            val symmetric_diff :
                              'a t ->
                              'a t ->
                              data_equal:('-> '-> bool) ->
                              (edge, 'a)
                              Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                              Base__.Sequence.t
                            val min_elt : 'a t -> (edge * 'a) option
                            val min_elt_exn : 'a t -> edge * 'a
                            val max_elt : 'a t -> (edge * 'a) option
                            val max_elt_exn : 'a t -> edge * 'a
                            val for_all : 'a t -> f:('-> bool) -> bool
                            val for_alli :
                              'a t -> f:(key:edge -> data:'-> bool) -> bool
                            val exists : 'a t -> f:('-> bool) -> bool
                            val existsi :
                              'a t -> f:(key:edge -> data:'-> bool) -> bool
                            val count : 'a t -> f:('-> bool) -> int
                            val counti :
                              'a t -> f:(key:edge -> data:'-> bool) -> int
                            val split :
                              'a t ->
                              edge -> 'a t * (edge * 'a) option * 'a t
                            val append :
                              lower_part:'a t ->
                              upper_part:'a t ->
                              [ `Ok of 'a t | `Overlapping_key_ranges ]
                            val subrange :
                              'a t ->
                              lower_bound:edge Base__.Maybe_bound.t ->
                              upper_bound:edge Base__.Maybe_bound.t -> 'a t
                            val fold_range_inclusive :
                              'a t ->
                              min:edge ->
                              max:edge ->
                              init:'->
                              f:(key:edge -> data:'-> '-> 'b) -> 'b
                            val range_to_alist :
                              'a t ->
                              min:edge -> max:edge -> (edge * 'a) list
                            val closest_key :
                              'a t ->
                              [ `Greater_or_equal_to
                              | `Greater_than
                              | `Less_or_equal_to
                              | `Less_than ] -> edge -> (edge * 'a) option
                            val nth : 'a t -> int -> (edge * 'a) option
                            val nth_exn : 'a t -> int -> edge * 'a
                            val rank : 'a t -> edge -> int option
                            val to_tree : 'a t -> 'a t
                            val to_sequence :
                              ?order:[ `Decreasing_key | `Increasing_key ] ->
                              ?keys_greater_or_equal_to:edge ->
                              ?keys_less_or_equal_to:edge ->
                              'a t -> (edge * 'a) Base__.Sequence.t
                            val obs :
                              edge Core_kernel__.Quickcheck.Observer.t ->
                              'Core_kernel__.Quickcheck.Observer.t ->
                              'v t Core_kernel__.Quickcheck.Observer.t
                            val shrinker :
                              edge Core_kernel__.Quickcheck.Shrinker.t ->
                              'Core_kernel__.Quickcheck.Shrinker.t ->
                              'v t Core_kernel__.Quickcheck.Shrinker.t
                            module Provide_of_sexp :
                              functor
                                (K : sig
                                       val t_of_sexp : Sexplib.Sexp.t -> edge
                                     end->
                                sig
                                  val t_of_sexp :
                                    (Sexplib.Sexp.t -> 'v_x__017_) ->
                                    Sexplib.Sexp.t -> 'v_x__017_ t
                                end
                            val t_of_sexp :
                              (Base__.Sexplib.Sexp.t -> 'a) ->
                              Base__.Sexplib.Sexp.t -> 'a t
                            val sexp_of_t :
                              ('-> Base__.Sexplib.Sexp.t) ->
                              'a t -> Base__.Sexplib.Sexp.t
                          end
                        type 'a t =
                            (edge, 'a, comparator_witness)
                            Core_kernel__.Core_map_intf.Map.t
                        val compare :
                          ('-> '-> Core_kernel__.Import.int) ->
                          'a t -> 'a t -> Core_kernel__.Import.int
                        val empty : 'a t
                        val singleton : edge -> '-> 'a t
                        val of_alist :
                          (edge * 'a) list ->
                          [ `Duplicate_key of edge | `Ok of 'a t ]
                        val of_alist_or_error :
                          (edge * 'a) list -> 'a t Base__.Or_error.t
                        val of_alist_exn : (edge * 'a) list -> 'a t
                        val of_alist_multi : (edge * 'a) list -> 'a list t
                        val of_alist_fold :
                          (edge * 'a) list ->
                          init:'-> f:('-> '-> 'b) -> 'b t
                        val of_alist_reduce :
                          (edge * 'a) list -> f:('-> '-> 'a) -> 'a t
                        val of_sorted_array :
                          (edge * 'a) array -> 'a t Base__.Or_error.t
                        val of_sorted_array_unchecked :
                          (edge * 'a) array -> 'a t
                        val of_increasing_iterator_unchecked :
                          len:int -> f:(int -> edge * 'a) -> 'a t
                        val of_iteri :
                          iteri:(f:(key:edge -> data:'-> unit) -> unit) ->
                          [ `Duplicate_key of edge | `Ok of 'v t ]
                        val of_tree : 'Tree.t -> 'a t
                        val of_hashtbl_exn :
                          (edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                        val gen :
                          edge Core_kernel__.Quickcheck.Generator.t ->
                          'Core_kernel__.Quickcheck.Generator.t ->
                          'a t Core_kernel__.Quickcheck.Generator.t
                        val invariants : 'a t -> bool
                        val is_empty : 'a t -> bool
                        val length : 'a t -> int
                        val add : 'a t -> key:edge -> data:'-> 'a t
                        val add_multi :
                          'a list t -> key:edge -> data:'-> 'a list t
                        val remove_multi : 'a list t -> edge -> 'a list t
                        val change :
                          'a t -> edge -> f:('a option -> 'a option) -> 'a t
                        val update :
                          'a t -> edge -> f:('a option -> 'a) -> 'a t
                        val find : 'a t -> edge -> 'a option
                        val find_exn : 'a t -> edge -> 'a
                        val remove : 'a t -> edge -> 'a t
                        val mem : 'a t -> edge -> bool
                        val iter_keys : 'a t -> f:(edge -> unit) -> unit
                        val iter : 'a t -> f:('-> unit) -> unit
                        val iteri :
                          'a t -> f:(key:edge -> data:'-> unit) -> unit
                        val iter2 :
                          'a t ->
                          'b t ->
                          f:(key:edge ->
                             data:[ `Both of 'a * 'b
                                  | `Left of 'a
                                  | `Right of 'b ] ->
                             unit) ->
                          unit
                        val map : 'a t -> f:('-> 'b) -> 'b t
                        val mapi :
                          'a t -> f:(key:edge -> data:'-> 'b) -> 'b t
                        val fold :
                          'a t ->
                          init:'->
                          f:(key:edge -> data:'-> '-> 'b) -> 'b
                        val fold_right :
                          'a t ->
                          init:'->
                          f:(key:edge -> data:'-> '-> 'b) -> 'b
                        val fold2 :
                          'a t ->
                          'b t ->
                          init:'->
                          f:(key:edge ->
                             data:[ `Both of 'a * 'b
                                  | `Left of 'a
                                  | `Right of 'b ] ->
                             '-> 'c) ->
                          'c
                        val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
                        val filter : 'a t -> f:('-> bool) -> 'a t
                        val filteri :
                          'a t -> f:(key:edge -> data:'-> bool) -> 'a t
                        val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                        val filter_mapi :
                          'a t ->
                          f:(key:edge -> data:'-> 'b option) -> 'b t
                        val partition_mapi :
                          'a t ->
                          f:(key:edge ->
                             data:'-> [ `Fst of '| `Snd of 'c ]) ->
                          'b t * 'c t
                        val partition_map :
                          'a t ->
                          f:('-> [ `Fst of '| `Snd of 'c ]) ->
                          'b t * 'c t
                        val partitioni_tf :
                          'a t ->
                          f:(key:edge -> data:'-> bool) -> 'a t * 'a t
                        val partition_tf :
                          'a t -> f:('-> bool) -> 'a t * 'a t
                        val compare_direct :
                          ('-> '-> int) -> 'a t -> 'a t -> int
                        val equal :
                          ('-> '-> bool) -> 'a t -> 'a t -> bool
                        val keys : 'a t -> edge list
                        val data : 'a t -> 'a list
                        val to_alist :
                          ?key_order:[ `Decreasing | `Increasing ] ->
                          'a t -> (edge * 'a) list
                        val validate :
                          name:(edge -> string) ->
                          'Base__.Validate.check ->
                          'a t Base__.Validate.check
                        val merge :
                          'a t ->
                          'b t ->
                          f:(key:edge ->
                             [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                             'c option) ->
                          'c t
                        val symmetric_diff :
                          'a t ->
                          'a t ->
                          data_equal:('-> '-> bool) ->
                          (edge, 'a)
                          Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                          Base__.Sequence.t
                        val min_elt : 'a t -> (edge * 'a) option
                        val min_elt_exn : 'a t -> edge * 'a
                        val max_elt : 'a t -> (edge * 'a) option
                        val max_elt_exn : 'a t -> edge * 'a
                        val for_all : 'a t -> f:('-> bool) -> bool
                        val for_alli :
                          'a t -> f:(key:edge -> data:'-> bool) -> bool
                        val exists : 'a t -> f:('-> bool) -> bool
                        val existsi :
                          'a t -> f:(key:edge -> data:'-> bool) -> bool
                        val count : 'a t -> f:('-> bool) -> int
                        val counti :
                          'a t -> f:(key:edge -> data:'-> bool) -> int
                        val split :
                          'a t -> edge -> 'a t * (edge * 'a) option * 'a t
                        val append :
                          lower_part:'a t ->
                          upper_part:'a t ->
                          [ `Ok of 'a t | `Overlapping_key_ranges ]
                        val subrange :
                          'a t ->
                          lower_bound:edge Base__.Maybe_bound.t ->
                          upper_bound:edge Base__.Maybe_bound.t -> 'a t
                        val fold_range_inclusive :
                          'a t ->
                          min:edge ->
                          max:edge ->
                          init:'->
                          f:(key:edge -> data:'-> '-> 'b) -> 'b
                        val range_to_alist :
                          'a t -> min:edge -> max:edge -> (edge * 'a) list
                        val closest_key :
                          'a t ->
                          [ `Greater_or_equal_to
                          | `Greater_than
                          | `Less_or_equal_to
                          | `Less_than ] -> edge -> (edge * 'a) option
                        val nth : 'a t -> int -> (edge * 'a) option
                        val nth_exn : 'a t -> int -> edge * 'a
                        val rank : 'a t -> edge -> int option
                        val to_tree : 'a t -> 'Tree.t
                        val to_sequence :
                          ?order:[ `Decreasing_key | `Increasing_key ] ->
                          ?keys_greater_or_equal_to:edge ->
                          ?keys_less_or_equal_to:edge ->
                          'a t -> (edge * 'a) Base__.Sequence.t
                        val obs :
                          edge Core_kernel__.Quickcheck.Observer.t ->
                          'Core_kernel__.Quickcheck.Observer.t ->
                          'v t Core_kernel__.Quickcheck.Observer.t
                        val shrinker :
                          edge Core_kernel__.Quickcheck.Shrinker.t ->
                          'Core_kernel__.Quickcheck.Shrinker.t ->
                          'v t Core_kernel__.Quickcheck.Shrinker.t
                        module Provide_of_sexp :
                          functor
                            (Key : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> edge
                                   end->
                            sig
                              val t_of_sexp :
                                (Sexplib.Sexp.t -> 'v_x__018_) ->
                                Sexplib.Sexp.t -> 'v_x__018_ t
                            end
                        module Provide_bin_io :
                          functor
                            (Key : sig
                                     val bin_t : edge Bin_prot.Type_class.t
                                     val bin_read_t :
                                       edge Bin_prot.Read.reader
                                     val __bin_read_t__ :
                                       (Core_kernel__.Import.int -> edge)
                                       Bin_prot.Read.reader
                                     val bin_reader_t :
                                       edge Bin_prot.Type_class.reader
                                     val bin_size_t :
                                       edge Bin_prot.Size.sizer
                                     val bin_write_t :
                                       edge Bin_prot.Write.writer
                                     val bin_writer_t :
                                       edge Bin_prot.Type_class.writer
                                     val bin_shape_t : Bin_prot.Shape.t
                                   end->
                            sig
                              val bin_shape_t :
                                Bin_prot.Shape.t -> Bin_prot.Shape.t
                              val bin_size_t :
                                ('a, 'a t) Bin_prot.Size.sizer1
                              val bin_write_t :
                                ('a, 'a t) Bin_prot.Write.writer1
                              val bin_read_t :
                                ('a, 'a t) Bin_prot.Read.reader1
                              val __bin_read_t__ :
                                ('a, int -> 'a t) Bin_prot.Read.reader1
                              val bin_writer_t :
                                ('a, 'a t) Bin_prot.Type_class.S1.writer
                              val bin_reader_t :
                                ('a, 'a t) Bin_prot.Type_class.S1.reader
                              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                            end
                        module Provide_hash :
                          functor
                            (Key : sig
                                     val hash_fold_t :
                                       Base__.Hash.state ->
                                       edge -> Base__.Hash.state
                                   end->
                            sig
                              val hash_fold_t :
                                (Ppx_hash_lib.Std.Hash.state ->
                                 '-> Ppx_hash_lib.Std.Hash.state) ->
                                Ppx_hash_lib.Std.Hash.state ->
                                'a t -> Ppx_hash_lib.Std.Hash.state
                            end
                        val t_of_sexp :
                          (Base__.Sexplib.Sexp.t -> 'a) ->
                          Base__.Sexplib.Sexp.t -> 'a t
                        val sexp_of_t :
                          ('-> Base__.Sexplib.Sexp.t) ->
                          'a t -> Base__.Sexplib.Sexp.t
                      end
                    module Set :
                      sig
                        module Elt :
                          sig
                            type t = edge
                            val t_of_sexp : Sexplib.Sexp.t -> t
                            val sexp_of_t : t -> Sexplib.Sexp.t
                            type comparator_witness =
                                Map.Key.comparator_witness
                            val comparator :
                              (t, comparator_witness)
                              Core_kernel__.Comparator.comparator
                          end
                        module Tree :
                          sig
                            type t =
                                (edge, comparator_witness)
                                Core_kernel__.Core_set_intf.Tree.t
                            val compare : t -> t -> Core_kernel__.Import.int
                            val length : t -> int
                            val is_empty : t -> bool
                            val iter : t -> f:(edge -> unit) -> unit
                            val fold :
                              t ->
                              init:'accum ->
                              f:('accum -> edge -> 'accum) -> 'accum
                            val fold_result :
                              t ->
                              init:'accum ->
                              f:('accum ->
                                 edge -> ('accum, 'e) Base__.Result.t) ->
                              ('accum, 'e) Base__.Result.t
                            val exists : t -> f:(edge -> bool) -> bool
                            val for_all : t -> f:(edge -> bool) -> bool
                            val count : t -> f:(edge -> bool) -> int
                            val sum :
                              (module Base__.Commutative_group.S with type t = 'sum) ->
                              t -> f:(edge -> 'sum) -> 'sum
                            val find : t -> f:(edge -> bool) -> edge option
                            val find_map :
                              t -> f:(edge -> 'a option) -> 'a option
                            val to_list : t -> edge list
                            val to_array : t -> edge array
                            val invariants : t -> bool
                            val mem : t -> edge -> bool
                            val add : t -> edge -> t
                            val remove : t -> edge -> t
                            val union : t -> t -> t
                            val inter : t -> t -> t
                            val diff : t -> t -> t
                            val symmetric_diff :
                              t ->
                              t ->
                              (edge, edge) Base__.Either.t Base__.Sequence.t
                            val compare_direct : t -> t -> int
                            val equal : t -> t -> bool
                            val is_subset : t -> of_:t -> bool
                            val subset : t -> t -> bool
                            val fold_until :
                              t ->
                              init:'->
                              f:('->
                                 edge ->
                                 ('b, 'stop)
                                 Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                              ('b, 'stop)
                              Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                            val fold_right :
                              t -> init:'-> f:(edge -> '-> 'b) -> 'b
                            val iter2 :
                              t ->
                              t ->
                              f:([ `Both of edge * edge
                                 | `Left of edge
                                 | `Right of edge ] -> unit) ->
                              unit
                            val filter : t -> f:(edge -> bool) -> t
                            val partition_tf : t -> f:(edge -> bool) -> t * t
                            val elements : t -> edge list
                            val min_elt : t -> edge option
                            val min_elt_exn : t -> edge
                            val max_elt : t -> edge option
                            val max_elt_exn : t -> edge
                            val choose : t -> edge option
                            val choose_exn : t -> edge
                            val split : t -> edge -> t * edge option * t
                            val group_by :
                              t -> equiv:(edge -> edge -> bool) -> t list
                            val find_exn : t -> f:(edge -> bool) -> edge
                            val find_index : t -> int -> edge option
                            val nth : t -> int -> edge option
                            val remove_index : t -> int -> t
                            val to_tree : t -> t
                            val to_sequence :
                              ?order:[ `Decreasing | `Increasing ] ->
                              ?greater_or_equal_to:edge ->
                              ?less_or_equal_to:edge ->
                              t -> edge Base__.Sequence.t
                            val merge_to_sequence :
                              ?order:[ `Decreasing | `Increasing ] ->
                              ?greater_or_equal_to:edge ->
                              ?less_or_equal_to:edge ->
                              t ->
                              t ->
                              (edge, edge)
                              Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                              Base__.Sequence.t
                            val to_map :
                              t ->
                              f:(edge -> 'data) ->
                              (edge, 'data, comparator_witness)
                              Core_kernel__.Core_set_intf.Map.t
                            val obs :
                              edge Core_kernel__.Quickcheck.Observer.t ->
                              t Core_kernel__.Quickcheck.Observer.t
                            val shrinker :
                              edge Core_kernel__.Quickcheck.Shrinker.t ->
                              t Core_kernel__.Quickcheck.Shrinker.t
                            val empty : t
                            val singleton : edge -> t
                            val union_list : t list -> t
                            val of_list : edge list -> t
                            val of_array : edge array -> t
                            val of_sorted_array :
                              edge array -> t Base__.Or_error.t
                            val of_sorted_array_unchecked : edge array -> t
                            val of_increasing_iterator_unchecked :
                              len:int -> f:(int -> edge) -> t
                            val stable_dedup_list : edge list -> edge list
                            val map :
                              ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                              f:('-> edge) -> t
                            val filter_map :
                              ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                              f:('-> edge option) -> t
                            val of_tree : t -> t
                            val of_hash_set :
                              edge Core_kernel__.Hash_set.t -> t
                            val of_hashtbl_keys :
                              (edge, 'a) Core_kernel__.Core_hashtbl.t -> t
                            val of_map_keys :
                              (edge, 'a, comparator_witness)
                              Core_kernel__.Core_set_intf.Map.t -> t
                            val gen :
                              edge Core_kernel__.Quickcheck.Generator.t ->
                              t Core_kernel__.Quickcheck.Generator.t
                            module Provide_of_sexp :
                              functor
                                (Elt : sig
                                         val t_of_sexp :
                                           Sexplib.Sexp.t -> edge
                                       end->
                                sig val t_of_sexp : Sexplib.Sexp.t -> t end
                            val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                            val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                          end
                        type t = (edge, comparator_witness) Base.Set.t
                        val compare : t -> t -> Core_kernel__.Import.int
                        val length : t -> int
                        val is_empty : t -> bool
                        val iter : t -> f:(edge -> unit) -> unit
                        val fold :
                          t ->
                          init:'accum ->
                          f:('accum -> edge -> 'accum) -> 'accum
                        val fold_result :
                          t ->
                          init:'accum ->
                          f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
                          ('accum, 'e) Base__.Result.t
                        val exists : t -> f:(edge -> bool) -> bool
                        val for_all : t -> f:(edge -> bool) -> bool
                        val count : t -> f:(edge -> bool) -> int
                        val sum :
                          (module Base__.Commutative_group.S with type t = 'sum) ->
                          t -> f:(edge -> 'sum) -> 'sum
                        val find : t -> f:(edge -> bool) -> edge option
                        val find_map :
                          t -> f:(edge -> 'a option) -> 'a option
                        val to_list : t -> edge list
                        val to_array : t -> edge array
                        val invariants : t -> bool
                        val mem : t -> edge -> bool
                        val add : t -> edge -> t
                        val remove : t -> edge -> t
                        val union : t -> t -> t
                        val inter : t -> t -> t
                        val diff : t -> t -> t
                        val symmetric_diff :
                          t ->
                          t -> (edge, edge) Base__.Either.t Base__.Sequence.t
                        val compare_direct : t -> t -> int
                        val equal : t -> t -> bool
                        val is_subset : t -> of_:t -> bool
                        val subset : t -> t -> bool
                        val fold_until :
                          t ->
                          init:'->
                          f:('->
                             edge ->
                             ('b, 'stop)
                             Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                          ('b, 'stop)
                          Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                        val fold_right :
                          t -> init:'-> f:(edge -> '-> 'b) -> 'b
                        val iter2 :
                          t ->
                          t ->
                          f:([ `Both of edge * edge
                             | `Left of edge
                             | `Right of edge ] -> unit) ->
                          unit
                        val filter : t -> f:(edge -> bool) -> t
                        val partition_tf : t -> f:(edge -> bool) -> t * t
                        val elements : t -> edge list
                        val min_elt : t -> edge option
                        val min_elt_exn : t -> edge
                        val max_elt : t -> edge option
                        val max_elt_exn : t -> edge
                        val choose : t -> edge option
                        val choose_exn : t -> edge
                        val split : t -> edge -> t * edge option * t
                        val group_by :
                          t -> equiv:(edge -> edge -> bool) -> t list
                        val find_exn : t -> f:(edge -> bool) -> edge
                        val find_index : t -> int -> edge option
                        val nth : t -> int -> edge option
                        val remove_index : t -> int -> t
                        val to_tree : t -> Tree.t
                        val to_sequence :
                          ?order:[ `Decreasing | `Increasing ] ->
                          ?greater_or_equal_to:edge ->
                          ?less_or_equal_to:edge ->
                          t -> edge Base__.Sequence.t
                        val merge_to_sequence :
                          ?order:[ `Decreasing | `Increasing ] ->
                          ?greater_or_equal_to:edge ->
                          ?less_or_equal_to:edge ->
                          t ->
                          t ->
                          (edge, edge)
                          Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                          Base__.Sequence.t
                        val to_map :
                          t ->
                          f:(edge -> 'data) ->
                          (edge, 'data, comparator_witness)
                          Core_kernel__.Core_set_intf.Map.t
                        val obs :
                          edge Core_kernel__.Quickcheck.Observer.t ->
                          t Core_kernel__.Quickcheck.Observer.t
                        val shrinker :
                          edge Core_kernel__.Quickcheck.Shrinker.t ->
                          t Core_kernel__.Quickcheck.Shrinker.t
                        val empty : t
                        val singleton : edge -> t
                        val union_list : t list -> t
                        val of_list : edge list -> t
                        val of_array : edge array -> t
                        val of_sorted_array :
                          edge array -> t Base__.Or_error.t
                        val of_sorted_array_unchecked : edge array -> t
                        val of_increasing_iterator_unchecked :
                          len:int -> f:(int -> edge) -> t
                        val stable_dedup_list : edge list -> edge list
                        val map : ('a, 'b) Base.Set.t -> f:('-> edge) -> t
                        val filter_map :
                          ('a, 'b) Base.Set.t -> f:('-> edge option) -> t
                        val of_tree : Tree.t -> t
                        val of_hash_set : edge Core_kernel__.Hash_set.t -> t
                        val of_hashtbl_keys :
                          (edge, 'a) Core_kernel__.Core_hashtbl.t -> t
                        val of_map_keys :
                          (edge, 'a, comparator_witness)
                          Core_kernel__.Core_set_intf.Map.t -> t
                        val gen :
                          edge Core_kernel__.Quickcheck.Generator.t ->
                          t Core_kernel__.Quickcheck.Generator.t
                        module Provide_of_sexp :
                          functor
                            (Elt : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> edge
                                   end->
                            sig val t_of_sexp : Sexplib.Sexp.t -> t end
                        module Provide_bin_io :
                          functor
                            (Elt : sig
                                     val bin_t : edge Bin_prot.Type_class.t
                                     val bin_read_t :
                                       edge Bin_prot.Read.reader
                                     val __bin_read_t__ :
                                       (Core_kernel__.Import.int -> edge)
                                       Bin_prot.Read.reader
                                     val bin_reader_t :
                                       edge Bin_prot.Type_class.reader
                                     val bin_size_t :
                                       edge Bin_prot.Size.sizer
                                     val bin_write_t :
                                       edge Bin_prot.Write.writer
                                     val bin_writer_t :
                                       edge Bin_prot.Type_class.writer
                                     val bin_shape_t : Bin_prot.Shape.t
                                   end->
                            sig
                              val bin_size_t : t Bin_prot.Size.sizer
                              val bin_write_t : t Bin_prot.Write.writer
                              val bin_read_t : t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                (int -> t) Bin_prot.Read.reader
                              val bin_shape_t : Bin_prot.Shape.t
                              val bin_writer_t : t Bin_prot.Type_class.writer
                              val bin_reader_t : t Bin_prot.Type_class.reader
                              val bin_t : t Bin_prot.Type_class.t
                            end
                        module Provide_hash :
                          functor
                            (Elt : sig
                                     val hash_fold_t :
                                       Base__.Hash.state ->
                                       edge -> Base__.Hash.state
                                   end->
                            sig
                              val hash_fold_t :
                                Ppx_hash_lib.Std.Hash.state ->
                                t -> Ppx_hash_lib.Std.Hash.state
                              val hash :
                                t -> Ppx_hash_lib.Std.Hash.hash_value
                            end
                        val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                        val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                      end
                    val hash : t -> Core_kernel__.Import.int
                    val compare : t -> t -> Core_kernel__.Import.int
                    val hashable :
                      t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
                    module Table :
                      sig
                        type key = t
                        type ('a, 'b) hashtbl = ('a, 'b) Node.Table.hashtbl
                        type 'b t = (key, 'b) hashtbl
                        val sexp_of_t :
                          ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                        type ('a, 'b) t_ = 'b t
                        type 'a key_ = key
                        val hashable :
                          key Core_kernel__.Core_hashtbl_intf.Hashable.t
                        val invariant :
                          'Base__.Invariant_intf.inv ->
                          'a t Base__.Invariant_intf.inv
                        val create :
                          (key, 'b, unit -> 'b t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist :
                          (key, 'b,
                           (key * 'b) list ->
                           [ `Duplicate_key of key | `Ok of 'b t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_report_all_dups :
                          (key, 'b,
                           (key * 'b) list ->
                           [ `Duplicate_keys of key list | `Ok of 'b t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_or_error :
                          (key, 'b,
                           (key * 'b) list -> 'b t Base__.Or_error.t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_exn :
                          (key, 'b, (key * 'b) list -> 'b t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_multi :
                          (key, 'b list, (key * 'b) list -> 'b list t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_mapped :
                          (key, 'b,
                           get_key:('-> key) ->
                           get_data:('-> 'b) ->
                           'r list ->
                           [ `Duplicate_keys of key list | `Ok of 'b t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_with_key :
                          (key, 'r,
                           get_key:('-> key) ->
                           'r list ->
                           [ `Duplicate_keys of key list | `Ok of 'r t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_with_key_or_error :
                          (key, 'r,
                           get_key:('-> key) ->
                           'r list -> 'r t Base__.Or_error.t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_with_key_exn :
                          (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val group :
                          (key, 'b,
                           get_key:('-> key) ->
                           get_data:('-> 'b) ->
                           combine:('-> '-> 'b) -> 'r list -> 'b t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                        val clear : 'a t -> unit
                        val copy : 'b t -> 'b t
                        val fold :
                          'b t ->
                          init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                        val iter_keys : 'a t -> f:(key -> unit) -> unit
                        val iter : 'b t -> f:('-> unit) -> unit
                        val iteri :
                          'b t -> f:(key:key -> data:'-> unit) -> unit
                        val iter_vals : 'b t -> f:('-> unit) -> unit
                        val existsi :
                          'b t -> f:(key:key -> data:'-> bool) -> bool
                        val exists : 'b t -> f:('-> bool) -> bool
                        val for_alli :
                          'b t -> f:(key:key -> data:'-> bool) -> bool
                        val for_all : 'b t -> f:('-> bool) -> bool
                        val counti :
                          'b t -> f:(key:key -> data:'-> bool) -> int
                        val count : 'b t -> f:('-> bool) -> int
                        val length : 'a t -> int
                        val is_empty : 'a t -> bool
                        val mem : 'a t -> key -> bool
                        val remove : 'a t -> key -> unit
                        val replace : 'b t -> key:key -> data:'-> unit
                        val set : 'b t -> key:key -> data:'-> unit
                        val add :
                          'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                        val add_or_error :
                          'b t ->
                          key:key -> data:'-> unit Base__.Or_error.t
                        val add_exn : 'b t -> key:key -> data:'-> unit
                        val change :
                          'b t -> key -> f:('b option -> 'b option) -> unit
                        val update :
                          'b t -> key -> f:('b option -> 'b) -> unit
                        val add_multi :
                          'b list t -> key:key -> data:'-> unit
                        val remove_multi : 'a list t -> key -> unit
                        val map : 'b t -> f:('-> 'c) -> 'c t
                        val mapi :
                          'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                        val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                        val filter_mapi :
                          'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                        val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                        val filter : 'b t -> f:('-> bool) -> 'b t
                        val filteri :
                          'b t -> f:(key:key -> data:'-> bool) -> 'b t
                        val partition_map :
                          'b t ->
                          f:('-> [ `Fst of '| `Snd of 'd ]) ->
                          'c t * 'd t
                        val partition_mapi :
                          'b t ->
                          f:(key:key ->
                             data:'-> [ `Fst of '| `Snd of 'd ]) ->
                          'c t * 'd t
                        val partition_tf :
                          'b t -> f:('-> bool) -> 'b t * 'b t
                        val partitioni_tf :
                          'b t ->
                          f:(key:key -> data:'-> bool) -> 'b t * 'b t
                        val find_or_add :
                          'b t -> key -> default:(unit -> 'b) -> 'b
                        val find : 'b t -> key -> 'b option
                        val find_exn : 'b t -> key -> 'b
                        val find_and_call :
                          'b t ->
                          key ->
                          if_found:('-> 'c) ->
                          if_not_found:(key -> 'c) -> 'c
                        val find_and_remove : 'b t -> key -> 'b option
                        val merge :
                          'a t ->
                          'b t ->
                          f:(key:key ->
                             [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                             'c option) ->
                          'c t
                        type 'a merge_into_action = Remove | Set_to of 'a
                        val merge_into :
                          src:'a t ->
                          dst:'b t ->
                          f:(key:key ->
                             '-> 'b option -> 'b merge_into_action) ->
                          unit
                        val keys : 'a t -> key list
                        val data : 'b t -> 'b list
                        val filter_keys_inplace :
                          'a t -> f:(key -> bool) -> unit
                        val filter_inplace : 'b t -> f:('-> bool) -> unit
                        val filteri_inplace :
                          'b t -> f:(key:key -> data:'-> bool) -> unit
                        val map_inplace : 'b t -> f:('-> 'b) -> unit
                        val mapi_inplace :
                          'b t -> f:(key:key -> data:'-> 'b) -> unit
                        val filter_map_inplace :
                          'b t -> f:('-> 'b option) -> unit
                        val filter_mapi_inplace :
                          'b t -> f:(key:key -> data:'-> 'b option) -> unit
                        val replace_all : 'b t -> f:('-> 'b) -> unit
                        val replace_alli :
                          'b t -> f:(key:key -> data:'-> 'b) -> unit
                        val filter_replace_all :
                          'b t -> f:('-> 'b option) -> unit
                        val filter_replace_alli :
                          'b t -> f:(key:key -> data:'-> 'b option) -> unit
                        val equal :
                          'b t -> 'b t -> ('-> '-> bool) -> bool
                        val similar :
                          'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                        val to_alist : 'b t -> (key * 'b) list
                        val validate :
                          name:(key -> string) ->
                          'Base__.Validate.check ->
                          'b t Base__.Validate.check
                        val incr :
                          ?by:int ->
                          ?remove_if_zero:bool -> int t -> key -> unit
                        val decr :
                          ?by:int ->
                          ?remove_if_zero:bool -> int t -> key -> unit
                        module Provide_of_sexp :
                          functor
                            (Key : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> key
                                   end->
                            sig
                              val t_of_sexp :
                                (Sexplib.Sexp.t -> 'v_x__001_) ->
                                Sexplib.Sexp.t -> 'v_x__001_ t
                            end
                        module Provide_bin_io :
                          functor
                            (Key : sig
                                     val bin_t : key Bin_prot.Type_class.t
                                     val bin_read_t :
                                       key Bin_prot.Read.reader
                                     val __bin_read_t__ :
                                       (Core_kernel__.Import.int -> key)
                                       Bin_prot.Read.reader
                                     val bin_reader_t :
                                       key Bin_prot.Type_class.reader
                                     val bin_size_t : key Bin_prot.Size.sizer
                                     val bin_write_t :
                                       key Bin_prot.Write.writer
                                     val bin_writer_t :
                                       key Bin_prot.Type_class.writer
                                     val bin_shape_t : Bin_prot.Shape.t
                                   end->
                            sig
                              val bin_t :
                                'Bin_prot.Type_class.t ->
                                'a t Bin_prot.Type_class.t
                              val bin_read_t :
                                'Bin_prot.Read.reader ->
                                'a t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                'Bin_prot.Read.reader ->
                                (Core_kernel__.Import.int -> 'a t)
                                Bin_prot.Read.reader
                              val bin_reader_t :
                                'Bin_prot.Type_class.reader ->
                                'a t Bin_prot.Type_class.reader
                              val bin_size_t :
                                'Bin_prot.Size.sizer ->
                                'a t Bin_prot.Size.sizer
                              val bin_write_t :
                                'Bin_prot.Write.writer ->
                                'a t Bin_prot.Write.writer
                              val bin_writer_t :
                                'Bin_prot.Type_class.writer ->
                                'a t Bin_prot.Type_class.writer
                              val bin_shape_t :
                                Bin_prot.Shape.t -> Bin_prot.Shape.t
                            end
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__002_) ->
                          Sexplib.Sexp.t -> 'v_x__002_ t
                      end
                    module Hash_set :
                      sig
                        type elt = t
                        type t = elt Core_kernel__.Hash_set.t
                        val sexp_of_t : t -> Sexplib.Sexp.t
                        type 'a t_ = t
                        type 'a elt_ = elt
                        val create :
                          ('a, unit -> t)
                          Core_kernel__.Hash_set_intf.create_options_without_hashable
                        val of_list :
                          ('a, elt list -> t)
                          Core_kernel__.Hash_set_intf.create_options_without_hashable
                        module Provide_of_sexp :
                          functor
                            (X : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> elt
                                 end->
                            sig val t_of_sexp : Sexplib.Sexp.t -> t end
                        module Provide_bin_io :
                          functor
                            (X : sig
                                   val bin_t : elt Bin_prot.Type_class.t
                                   val bin_read_t : elt Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> elt)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     elt Bin_prot.Type_class.reader
                                   val bin_size_t : elt Bin_prot.Size.sizer
                                   val bin_write_t :
                                     elt Bin_prot.Write.writer
                                   val bin_writer_t :
                                     elt Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                            sig
                              val bin_t : t Bin_prot.Type_class.t
                              val bin_read_t : t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                (Core_kernel__.Import.int -> t)
                                Bin_prot.Read.reader
                              val bin_reader_t : t Bin_prot.Type_class.reader
                              val bin_size_t : t Bin_prot.Size.sizer
                              val bin_write_t : t Bin_prot.Write.writer
                              val bin_writer_t : t Bin_prot.Type_class.writer
                              val bin_shape_t : Bin_prot.Shape.t
                            end
                        val t_of_sexp : Sexplib.Sexp.t -> t
                      end
                    module Hash_queue :
                      sig
                        module Key :
                          sig
                            type t = edge
                            val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                            val compare : t -> t -> int
                            val hash : t -> int
                          end
                        type 'a t
                        val sexp_of_t :
                          ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                        val length : 'a t -> int
                        val is_empty : 'a t -> bool
                        val iter : 'a t -> f:('-> unit) -> unit
                        val fold :
                          'a t ->
                          init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                        val fold_result :
                          'a t ->
                          init:'accum ->
                          f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                          ('accum, 'e) Base__.Result.t
                        val fold_until :
                          'a t ->
                          init:'accum ->
                          f:('accum ->
                             '->
                             ('accum, 'stop)
                             Base.Container_intf.Continue_or_stop.t) ->
                          ('accum, 'stop)
                          Base.Container_intf.Finished_or_stopped_early.t
                        val exists : 'a t -> f:('-> bool) -> bool
                        val for_all : 'a t -> f:('-> bool) -> bool
                        val count : 'a t -> f:('-> bool) -> int
                        val sum :
                          (module Base__.Commutative_group.S with type t = 'sum) ->
                          'a t -> f:('-> 'sum) -> 'sum
                        val find : 'a t -> f:('-> bool) -> 'a option
                        val find_map :
                          'a t -> f:('-> 'b option) -> 'b option
                        val to_list : 'a t -> 'a list
                        val to_array : 'a t -> 'a array
                        val min_elt :
                          'a t -> cmp:('-> '-> int) -> 'a option
                        val max_elt :
                          'a t -> cmp:('-> '-> int) -> 'a option
                        val invariant : 'a t -> Core_kernel__.Import.unit
                        val create :
                          ?growth_allowed:Core_kernel__.Import.bool ->
                          ?size:Core_kernel__.Import.int ->
                          Core_kernel__.Import.unit -> 'a t
                        val clear : 'a t -> Core_kernel__.Import.unit
                        val mem : 'a t -> edge -> Core_kernel__.Import.bool
                        val lookup :
                          'a t -> edge -> 'Core_kernel__.Import.option
                        val lookup_exn : 'a t -> edge -> 'a
                        val enqueue :
                          'a t ->
                          edge -> '-> [ `Key_already_present | `Ok ]
                        val enqueue_exn :
                          'a t -> edge -> '-> Core_kernel__.Import.unit
                        val lookup_and_move_to_back :
                          'a t -> edge -> 'Core_kernel__.Import.option
                        val lookup_and_move_to_back_exn : 'a t -> edge -> 'a
                        val first : 'a t -> 'Core_kernel__.Import.option
                        val first_with_key :
                          'a t -> (edge * 'a) Core_kernel__.Import.option
                        val keys : 'a t -> edge Core_kernel__.Import.list
                        val dequeue : 'a t -> 'Core_kernel__.Import.option
                        val dequeue_exn : 'a t -> 'a
                        val dequeue_with_key :
                          'a t -> (edge * 'a) Core_kernel__.Import.option
                        val dequeue_with_key_exn : 'a t -> edge * 'a
                        val dequeue_all :
                          'a t ->
                          f:('-> Core_kernel__.Import.unit) ->
                          Core_kernel__.Import.unit
                        val remove : 'a t -> edge -> [ `No_such_key | `Ok ]
                        val remove_exn :
                          'a t -> edge -> Core_kernel__.Import.unit
                        val replace :
                          'a t -> edge -> '-> [ `No_such_key | `Ok ]
                        val replace_exn :
                          'a t -> edge -> '-> Core_kernel__.Import.unit
                        val iteri :
                          'a t ->
                          f:(key:edge -> data:'-> Core_kernel__.Import.unit) ->
                          Core_kernel__.Import.unit
                        val foldi :
                          'a t ->
                          init:'->
                          f:('-> key:edge -> data:'-> 'b) -> 'b
                      end
                  end
                val empty : t
                val nodes : t -> node Regular.Std.seq
                val edges : t -> edge Regular.Std.seq
                val is_directed : bool
                val number_of_edges : t -> int
                val number_of_nodes : t -> int
                val ( >= ) : t -> t -> bool
                val ( <= ) : t -> t -> bool
                val ( = ) : t -> t -> bool
                val ( > ) : t -> t -> bool
                val ( < ) : t -> t -> bool
                val ( <> ) : t -> t -> bool
                val equal : t -> t -> bool
                val min : t -> t -> t
                val max : t -> t -> t
                val ascending : t -> t -> int
                val descending : t -> t -> int
                val between : t -> low:t -> high:t -> bool
                val clamp_exn : t -> min:t -> max:t -> t
                val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
                type comparator_witness
                val comparator :
                  (t, comparator_witness) Base__.Comparator.comparator
                val validate_lbound :
                  min:t Base__.Maybe_bound.t -> t Base__.Validate.check
                val validate_ubound :
                  max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                val validate_bound :
                  min:t Base__.Maybe_bound.t ->
                  max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                module Replace_polymorphic_compare :
                  sig
                    val ( >= ) : t -> t -> bool
                    val ( <= ) : t -> t -> bool
                    val ( = ) : t -> t -> bool
                    val ( > ) : t -> t -> bool
                    val ( < ) : t -> t -> bool
                    val ( <> ) : t -> t -> bool
                    val equal : t -> t -> bool
                    val compare : t -> t -> int
                    val min : t -> t -> t
                    val max : t -> t -> t
                  end
                module Map :
                  sig
                    module Key :
                      sig
                        type t = Edge.graph
                        val t_of_sexp : Sexplib.Sexp.t -> t
                        val sexp_of_t : t -> Sexplib.Sexp.t
                        type comparator_witness = comparator_witness
                        val comparator :
                          (t, comparator_witness)
                          Core_kernel__.Comparator.comparator
                      end
                    module Tree :
                      sig
                        type 'a t =
                            (Key.t, 'a, comparator_witness)
                            Core_kernel__.Core_map_intf.Tree.t
                        val empty : 'a t
                        val singleton : Key.t -> '-> 'a t
                        val of_alist :
                          (Key.t * 'a) list ->
                          [ `Duplicate_key of Key.t | `Ok of 'a t ]
                        val of_alist_or_error :
                          (Key.t * 'a) list -> 'a t Base__.Or_error.t
                        val of_alist_exn : (Key.t * 'a) list -> 'a t
                        val of_alist_multi : (Key.t * 'a) list -> 'a list t
                        val of_alist_fold :
                          (Key.t * 'a) list ->
                          init:'-> f:('-> '-> 'b) -> 'b t
                        val of_alist_reduce :
                          (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                        val of_sorted_array :
                          (Key.t * 'a) array -> 'a t Base__.Or_error.t
                        val of_sorted_array_unchecked :
                          (Key.t * 'a) array -> 'a t
                        val of_increasing_iterator_unchecked :
                          len:int -> f:(int -> Key.t * 'a) -> 'a t
                        val of_iteri :
                          iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                          [ `Duplicate_key of Key.t | `Ok of 'v t ]
                        val of_tree : 'a t -> 'a t
                        val of_hashtbl_exn :
                          (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                        val gen :
                          Key.t Core_kernel__.Quickcheck.Generator.t ->
                          'Core_kernel__.Quickcheck.Generator.t ->
                          'a t Core_kernel__.Quickcheck.Generator.t
                        val invariants : 'a t -> bool
                        val is_empty : 'a t -> bool
                        val length : 'a t -> int
                        val add : 'a t -> key:Key.t -> data:'-> 'a t
                        val add_multi :
                          'a list t -> key:Key.t -> data:'-> 'a list t
                        val remove_multi : 'a list t -> Key.t -> 'a list t
                        val change :
                          'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                        val update :
                          'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                        val find : 'a t -> Key.t -> 'a option
                        val find_exn : 'a t -> Key.t -> 'a
                        val remove : 'a t -> Key.t -> 'a t
                        val mem : 'a t -> Key.t -> bool
                        val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                        val iter : 'a t -> f:('-> unit) -> unit
                        val iteri :
                          'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                        val iter2 :
                          'a t ->
                          'b t ->
                          f:(key:Key.t ->
                             data:[ `Both of 'a * 'b
                                  | `Left of 'a
                                  | `Right of 'b ] ->
                             unit) ->
                          unit
                        val map : 'a t -> f:('-> 'b) -> 'b t
                        val mapi :
                          'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                        val fold :
                          'a t ->
                          init:'->
                          f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                        val fold_right :
                          'a t ->
                          init:'->
                          f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                        val fold2 :
                          'a t ->
                          'b t ->
                          init:'->
                          f:(key:Key.t ->
                             data:[ `Both of 'a * 'b
                                  | `Left of 'a
                                  | `Right of 'b ] ->
                             '-> 'c) ->
                          'c
                        val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                        val filter : 'a t -> f:('-> bool) -> 'a t
                        val filteri :
                          'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                        val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                        val filter_mapi :
                          'a t ->
                          f:(key:Key.t -> data:'-> 'b option) -> 'b t
                        val partition_mapi :
                          'a t ->
                          f:(key:Key.t ->
                             data:'-> [ `Fst of '| `Snd of 'c ]) ->
                          'b t * 'c t
                        val partition_map :
                          'a t ->
                          f:('-> [ `Fst of '| `Snd of 'c ]) ->
                          'b t * 'c t
                        val partitioni_tf :
                          'a t ->
                          f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                        val partition_tf :
                          'a t -> f:('-> bool) -> 'a t * 'a t
                        val compare_direct :
                          ('-> '-> int) -> 'a t -> 'a t -> int
                        val equal :
                          ('-> '-> bool) -> 'a t -> 'a t -> bool
                        val keys : 'a t -> Key.t list
                        val data : 'a t -> 'a list
                        val to_alist :
                          ?key_order:[ `Decreasing | `Increasing ] ->
                          'a t -> (Key.t * 'a) list
                        val validate :
                          name:(Key.t -> string) ->
                          'Base__.Validate.check ->
                          'a t Base__.Validate.check
                        val merge :
                          'a t ->
                          'b t ->
                          f:(key:Key.t ->
                             [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                             'c option) ->
                          'c t
                        val symmetric_diff :
                          'a t ->
                          'a t ->
                          data_equal:('-> '-> bool) ->
                          (Key.t, 'a)
                          Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                          Base__.Sequence.t
                        val min_elt : 'a t -> (Key.t * 'a) option
                        val min_elt_exn : 'a t -> Key.t * 'a
                        val max_elt : 'a t -> (Key.t * 'a) option
                        val max_elt_exn : 'a t -> Key.t * 'a
                        val for_all : 'a t -> f:('-> bool) -> bool
                        val for_alli :
                          'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                        val exists : 'a t -> f:('-> bool) -> bool
                        val existsi :
                          'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                        val count : 'a t -> f:('-> bool) -> int
                        val counti :
                          'a t -> f:(key:Key.t -> data:'-> bool) -> int
                        val split :
                          'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                        val append :
                          lower_part:'a t ->
                          upper_part:'a t ->
                          [ `Ok of 'a t | `Overlapping_key_ranges ]
                        val subrange :
                          'a t ->
                          lower_bound:Key.t Base__.Maybe_bound.t ->
                          upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                        val fold_range_inclusive :
                          'a t ->
                          min:Key.t ->
                          max:Key.t ->
                          init:'->
                          f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                        val range_to_alist :
                          'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                        val closest_key :
                          'a t ->
                          [ `Greater_or_equal_to
                          | `Greater_than
                          | `Less_or_equal_to
                          | `Less_than ] -> Key.t -> (Key.t * 'a) option
                        val nth : 'a t -> int -> (Key.t * 'a) option
                        val nth_exn : 'a t -> int -> Key.t * 'a
                        val rank : 'a t -> Key.t -> int option
                        val to_tree : 'a t -> 'a t
                        val to_sequence :
                          ?order:[ `Decreasing_key | `Increasing_key ] ->
                          ?keys_greater_or_equal_to:Key.t ->
                          ?keys_less_or_equal_to:Key.t ->
                          'a t -> (Key.t * 'a) Base__.Sequence.t
                        val obs :
                          Key.t Core_kernel__.Quickcheck.Observer.t ->
                          'Core_kernel__.Quickcheck.Observer.t ->
                          'v t Core_kernel__.Quickcheck.Observer.t
                        val shrinker :
                          Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                          'Core_kernel__.Quickcheck.Shrinker.t ->
                          'v t Core_kernel__.Quickcheck.Shrinker.t
                        module Provide_of_sexp :
                          functor
                            (K : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> Key.t
                                 end->
                            sig
                              val t_of_sexp :
                                (Sexplib.Sexp.t -> 'v_x__017_) ->
                                Sexplib.Sexp.t -> 'v_x__017_ t
                            end
                        val t_of_sexp :
                          (Base__.Sexplib.Sexp.t -> 'a) ->
                          Base__.Sexplib.Sexp.t -> 'a t
                        val sexp_of_t :
                          ('-> Base__.Sexplib.Sexp.t) ->
                          'a t -> Base__.Sexplib.Sexp.t
                      end
                    type 'a t =
                        (Key.t, 'a, comparator_witness)
                        Core_kernel__.Core_map_intf.Map.t
                    val compare :
                      ('-> '-> Core_kernel__.Import.int) ->
                      'a t -> 'a t -> Core_kernel__.Import.int
                    val empty : 'a t
                    val singleton : Key.t -> '-> 'a t
                    val of_alist :
                      (Key.t * 'a) list ->
                      [ `Duplicate_key of Key.t | `Ok of 'a t ]
                    val of_alist_or_error :
                      (Key.t * 'a) list -> 'a t Base__.Or_error.t
                    val of_alist_exn : (Key.t * 'a) list -> 'a t
                    val of_alist_multi : (Key.t * 'a) list -> 'a list t
                    val of_alist_fold :
                      (Key.t * 'a) list ->
                      init:'-> f:('-> '-> 'b) -> 'b t
                    val of_alist_reduce :
                      (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                    val of_sorted_array :
                      (Key.t * 'a) array -> 'a t Base__.Or_error.t
                    val of_sorted_array_unchecked :
                      (Key.t * 'a) array -> 'a t
                    val of_increasing_iterator_unchecked :
                      len:int -> f:(int -> Key.t * 'a) -> 'a t
                    val of_iteri :
                      iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                      [ `Duplicate_key of Key.t | `Ok of 'v t ]
                    val of_tree : 'Tree.t -> 'a t
                    val of_hashtbl_exn :
                      (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                    val gen :
                      Key.t Core_kernel__.Quickcheck.Generator.t ->
                      'Core_kernel__.Quickcheck.Generator.t ->
                      'a t Core_kernel__.Quickcheck.Generator.t
                    val invariants : 'a t -> bool
                    val is_empty : 'a t -> bool
                    val length : 'a t -> int
                    val add : 'a t -> key:Key.t -> data:'-> 'a t
                    val add_multi :
                      'a list t -> key:Key.t -> data:'-> 'a list t
                    val remove_multi : 'a list t -> Key.t -> 'a list t
                    val change :
                      'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                    val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                    val find : 'a t -> Key.t -> 'a option
                    val find_exn : 'a t -> Key.t -> 'a
                    val remove : 'a t -> Key.t -> 'a t
                    val mem : 'a t -> Key.t -> bool
                    val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                    val iter : 'a t -> f:('-> unit) -> unit
                    val iteri :
                      'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                    val iter2 :
                      'a t ->
                      'b t ->
                      f:(key:Key.t ->
                         data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                         unit) ->
                      unit
                    val map : 'a t -> f:('-> 'b) -> 'b t
                    val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                    val fold :
                      'a t ->
                      init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                    val fold_right :
                      'a t ->
                      init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                    val fold2 :
                      'a t ->
                      'b t ->
                      init:'->
                      f:(key:Key.t ->
                         data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                         '-> 'c) ->
                      'c
                    val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                    val filter : 'a t -> f:('-> bool) -> 'a t
                    val filteri :
                      'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                    val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                    val filter_mapi :
                      'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                    val partition_mapi :
                      'a t ->
                      f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                      'b t * 'c t
                    val partition_map :
                      'a t ->
                      f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                    val partitioni_tf :
                      'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                    val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                    val compare_direct :
                      ('-> '-> int) -> 'a t -> 'a t -> int
                    val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                    val keys : 'a t -> Key.t list
                    val data : 'a t -> 'a list
                    val to_alist :
                      ?key_order:[ `Decreasing | `Increasing ] ->
                      'a t -> (Key.t * 'a) list
                    val validate :
                      name:(Key.t -> string) ->
                      'Base__.Validate.check -> 'a t Base__.Validate.check
                    val merge :
                      'a t ->
                      'b t ->
                      f:(key:Key.t ->
                         [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                         'c option) ->
                      'c t
                    val symmetric_diff :
                      'a t ->
                      'a t ->
                      data_equal:('-> '-> bool) ->
                      (Key.t, 'a)
                      Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                      Base__.Sequence.t
                    val min_elt : 'a t -> (Key.t * 'a) option
                    val min_elt_exn : 'a t -> Key.t * 'a
                    val max_elt : 'a t -> (Key.t * 'a) option
                    val max_elt_exn : 'a t -> Key.t * 'a
                    val for_all : 'a t -> f:('-> bool) -> bool
                    val for_alli :
                      'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                    val exists : 'a t -> f:('-> bool) -> bool
                    val existsi :
                      'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                    val count : 'a t -> f:('-> bool) -> int
                    val counti :
                      'a t -> f:(key:Key.t -> data:'-> bool) -> int
                    val split :
                      'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                    val append :
                      lower_part:'a t ->
                      upper_part:'a t ->
                      [ `Ok of 'a t | `Overlapping_key_ranges ]
                    val subrange :
                      'a t ->
                      lower_bound:Key.t Base__.Maybe_bound.t ->
                      upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                    val fold_range_inclusive :
                      'a t ->
                      min:Key.t ->
                      max:Key.t ->
                      init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                    val range_to_alist :
                      'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                    val closest_key :
                      'a t ->
                      [ `Greater_or_equal_to
                      | `Greater_than
                      | `Less_or_equal_to
                      | `Less_than ] -> Key.t -> (Key.t * 'a) option
                    val nth : 'a t -> int -> (Key.t * 'a) option
                    val nth_exn : 'a t -> int -> Key.t * 'a
                    val rank : 'a t -> Key.t -> int option
                    val to_tree : 'a t -> 'Tree.t
                    val to_sequence :
                      ?order:[ `Decreasing_key | `Increasing_key ] ->
                      ?keys_greater_or_equal_to:Key.t ->
                      ?keys_less_or_equal_to:Key.t ->
                      'a t -> (Key.t * 'a) Base__.Sequence.t
                    val obs :
                      Key.t Core_kernel__.Quickcheck.Observer.t ->
                      'Core_kernel__.Quickcheck.Observer.t ->
                      'v t Core_kernel__.Quickcheck.Observer.t
                    val shrinker :
                      Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                      'Core_kernel__.Quickcheck.Shrinker.t ->
                      'v t Core_kernel__.Quickcheck.Shrinker.t
                    module Provide_of_sexp :
                      functor
                        (Key : sig
                                 val t_of_sexp : Sexplib.Sexp.t -> Key.t
                               end->
                        sig
                          val t_of_sexp :
                            (Sexplib.Sexp.t -> 'v_x__018_) ->
                            Sexplib.Sexp.t -> 'v_x__018_ t
                        end
                    module Provide_bin_io :
                      functor
                        (Key : sig
                                 val bin_t : Key.t Bin_prot.Type_class.t
                                 val bin_read_t : Key.t Bin_prot.Read.reader
                                 val __bin_read_t__ :
                                   (Core_kernel__.Import.int -> Key.t)
                                   Bin_prot.Read.reader
                                 val bin_reader_t :
                                   Key.t Bin_prot.Type_class.reader
                                 val bin_size_t : Key.t Bin_prot.Size.sizer
                                 val bin_write_t :
                                   Key.t Bin_prot.Write.writer
                                 val bin_writer_t :
                                   Key.t Bin_prot.Type_class.writer
                                 val bin_shape_t : Bin_prot.Shape.t
                               end->
                        sig
                          val bin_shape_t :
                            Bin_prot.Shape.t -> Bin_prot.Shape.t
                          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                          val __bin_read_t__ :
                            ('a, int -> 'a t) Bin_prot.Read.reader1
                          val bin_writer_t :
                            ('a, 'a t) Bin_prot.Type_class.S1.writer
                          val bin_reader_t :
                            ('a, 'a t) Bin_prot.Type_class.S1.reader
                          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                        end
                    module Provide_hash :
                      functor
                        (Key : sig
                                 val hash_fold_t :
                                   Base__.Hash.state ->
                                   Key.t -> Base__.Hash.state
                               end->
                        sig
                          val hash_fold_t :
                            (Ppx_hash_lib.Std.Hash.state ->
                             '-> Ppx_hash_lib.Std.Hash.state) ->
                            Ppx_hash_lib.Std.Hash.state ->
                            'a t -> Ppx_hash_lib.Std.Hash.state
                        end
                    val t_of_sexp :
                      (Base__.Sexplib.Sexp.t -> 'a) ->
                      Base__.Sexplib.Sexp.t -> 'a t
                    val sexp_of_t :
                      ('-> Base__.Sexplib.Sexp.t) ->
                      'a t -> Base__.Sexplib.Sexp.t
                  end
                module Set :
                  sig
                    module Elt :
                      sig
                        type t = Edge.graph
                        val t_of_sexp : Sexplib.Sexp.t -> t
                        val sexp_of_t : t -> Sexplib.Sexp.t
                        type comparator_witness = Map.Key.comparator_witness
                        val comparator :
                          (t, comparator_witness)
                          Core_kernel__.Comparator.comparator
                      end
                    module Tree :
                      sig
                        type t =
                            (Elt.t, comparator_witness)
                            Core_kernel__.Core_set_intf.Tree.t
                        val compare : t -> t -> Core_kernel__.Import.int
                        val length : t -> int
                        val is_empty : t -> bool
                        val iter : t -> f:(Elt.t -> unit) -> unit
                        val fold :
                          t ->
                          init:'accum ->
                          f:('accum -> Elt.t -> 'accum) -> 'accum
                        val fold_result :
                          t ->
                          init:'accum ->
                          f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                          ('accum, 'e) Base__.Result.t
                        val exists : t -> f:(Elt.t -> bool) -> bool
                        val for_all : t -> f:(Elt.t -> bool) -> bool
                        val count : t -> f:(Elt.t -> bool) -> int
                        val sum :
                          (module Base__.Commutative_group.S with type t = 'sum) ->
                          t -> f:(Elt.t -> 'sum) -> 'sum
                        val find : t -> f:(Elt.t -> bool) -> Elt.t option
                        val find_map :
                          t -> f:(Elt.t -> 'a option) -> 'a option
                        val to_list : t -> Elt.t list
                        val to_array : t -> Elt.t array
                        val invariants : t -> bool
                        val mem : t -> Elt.t -> bool
                        val add : t -> Elt.t -> t
                        val remove : t -> Elt.t -> t
                        val union : t -> t -> t
                        val inter : t -> t -> t
                        val diff : t -> t -> t
                        val symmetric_diff :
                          t ->
                          t ->
                          (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                        val compare_direct : t -> t -> int
                        val equal : t -> t -> bool
                        val is_subset : t -> of_:t -> bool
                        val subset : t -> t -> bool
                        val fold_until :
                          t ->
                          init:'->
                          f:('->
                             Elt.t ->
                             ('b, 'stop)
                             Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                          ('b, 'stop)
                          Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                        val fold_right :
                          t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                        val iter2 :
                          t ->
                          t ->
                          f:([ `Both of Elt.t * Elt.t
                             | `Left of Elt.t
                             | `Right of Elt.t ] -> unit) ->
                          unit
                        val filter : t -> f:(Elt.t -> bool) -> t
                        val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                        val elements : t -> Elt.t list
                        val min_elt : t -> Elt.t option
                        val min_elt_exn : t -> Elt.t
                        val max_elt : t -> Elt.t option
                        val max_elt_exn : t -> Elt.t
                        val choose : t -> Elt.t option
                        val choose_exn : t -> Elt.t
                        val split : t -> Elt.t -> t * Elt.t option * t
                        val group_by :
                          t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                        val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                        val find_index : t -> int -> Elt.t option
                        val nth : t -> int -> Elt.t option
                        val remove_index : t -> int -> t
                        val to_tree : t -> t
                        val to_sequence :
                          ?order:[ `Decreasing | `Increasing ] ->
                          ?greater_or_equal_to:Elt.t ->
                          ?less_or_equal_to:Elt.t ->
                          t -> Elt.t Base__.Sequence.t
                        val merge_to_sequence :
                          ?order:[ `Decreasing | `Increasing ] ->
                          ?greater_or_equal_to:Elt.t ->
                          ?less_or_equal_to:Elt.t ->
                          t ->
                          t ->
                          (Elt.t, Elt.t)
                          Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                          Base__.Sequence.t
                        val to_map :
                          t ->
                          f:(Elt.t -> 'data) ->
                          (Elt.t, 'data, comparator_witness)
                          Core_kernel__.Core_set_intf.Map.t
                        val obs :
                          Elt.t Core_kernel__.Quickcheck.Observer.t ->
                          t Core_kernel__.Quickcheck.Observer.t
                        val shrinker :
                          Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                          t Core_kernel__.Quickcheck.Shrinker.t
                        val empty : t
                        val singleton : Elt.t -> t
                        val union_list : t list -> t
                        val of_list : Elt.t list -> t
                        val of_array : Elt.t array -> t
                        val of_sorted_array :
                          Elt.t array -> t Base__.Or_error.t
                        val of_sorted_array_unchecked : Elt.t array -> t
                        val of_increasing_iterator_unchecked :
                          len:int -> f:(int -> Elt.t) -> t
                        val stable_dedup_list : Elt.t list -> Elt.t list
                        val map :
                          ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                          f:('-> Elt.t) -> t
                        val filter_map :
                          ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                          f:('-> Elt.t option) -> t
                        val of_tree : t -> t
                        val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                        val of_hashtbl_keys :
                          (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                        val of_map_keys :
                          (Elt.t, 'a, comparator_witness)
                          Core_kernel__.Core_set_intf.Map.t -> t
                        val gen :
                          Elt.t Core_kernel__.Quickcheck.Generator.t ->
                          t Core_kernel__.Quickcheck.Generator.t
                        module Provide_of_sexp :
                          functor
                            (Elt : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> Elt.t
                                   end->
                            sig val t_of_sexp : Sexplib.Sexp.t -> t end
                        val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                        val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                      end
                    type t = (Elt.t, comparator_witness) Base.Set.t
                    val compare : t -> t -> Core_kernel__.Import.int
                    val length : t -> int
                    val is_empty : t -> bool
                    val iter : t -> f:(Elt.t -> unit) -> unit
                    val fold :
                      t ->
                      init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                    val fold_result :
                      t ->
                      init:'accum ->
                      f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                      ('accum, 'e) Base__.Result.t
                    val exists : t -> f:(Elt.t -> bool) -> bool
                    val for_all : t -> f:(Elt.t -> bool) -> bool
                    val count : t -> f:(Elt.t -> bool) -> int
                    val sum :
                      (module Base__.Commutative_group.S with type t = 'sum) ->
                      t -> f:(Elt.t -> 'sum) -> 'sum
                    val find : t -> f:(Elt.t -> bool) -> Elt.t option
                    val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                    val to_list : t -> Elt.t list
                    val to_array : t -> Elt.t array
                    val invariants : t -> bool
                    val mem : t -> Elt.t -> bool
                    val add : t -> Elt.t -> t
                    val remove : t -> Elt.t -> t
                    val union : t -> t -> t
                    val inter : t -> t -> t
                    val diff : t -> t -> t
                    val symmetric_diff :
                      t ->
                      t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                    val compare_direct : t -> t -> int
                    val equal : t -> t -> bool
                    val is_subset : t -> of_:t -> bool
                    val subset : t -> t -> bool
                    val fold_until :
                      t ->
                      init:'->
                      f:('->
                         Elt.t ->
                         ('b, 'stop)
                         Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                      ('b, 'stop)
                      Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                    val fold_right :
                      t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                    val iter2 :
                      t ->
                      t ->
                      f:([ `Both of Elt.t * Elt.t
                         | `Left of Elt.t
                         | `Right of Elt.t ] -> unit) ->
                      unit
                    val filter : t -> f:(Elt.t -> bool) -> t
                    val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                    val elements : t -> Elt.t list
                    val min_elt : t -> Elt.t option
                    val min_elt_exn : t -> Elt.t
                    val max_elt : t -> Elt.t option
                    val max_elt_exn : t -> Elt.t
                    val choose : t -> Elt.t option
                    val choose_exn : t -> Elt.t
                    val split : t -> Elt.t -> t * Elt.t option * t
                    val group_by :
                      t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                    val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                    val find_index : t -> int -> Elt.t option
                    val nth : t -> int -> Elt.t option
                    val remove_index : t -> int -> t
                    val to_tree : t -> Tree.t
                    val to_sequence :
                      ?order:[ `Decreasing | `Increasing ] ->
                      ?greater_or_equal_to:Elt.t ->
                      ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                    val merge_to_sequence :
                      ?order:[ `Decreasing | `Increasing ] ->
                      ?greater_or_equal_to:Elt.t ->
                      ?less_or_equal_to:Elt.t ->
                      t ->
                      t ->
                      (Elt.t, Elt.t)
                      Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                      Base__.Sequence.t
                    val to_map :
                      t ->
                      f:(Elt.t -> 'data) ->
                      (Elt.t, 'data, comparator_witness)
                      Core_kernel__.Core_set_intf.Map.t
                    val obs :
                      Elt.t Core_kernel__.Quickcheck.Observer.t ->
                      t Core_kernel__.Quickcheck.Observer.t
                    val shrinker :
                      Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                      t Core_kernel__.Quickcheck.Shrinker.t
                    val empty : t
                    val singleton : Elt.t -> t
                    val union_list : t list -> t
                    val of_list : Elt.t list -> t
                    val of_array : Elt.t array -> t
                    val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                    val of_sorted_array_unchecked : Elt.t array -> t
                    val of_increasing_iterator_unchecked :
                      len:int -> f:(int -> Elt.t) -> t
                    val stable_dedup_list : Elt.t list -> Elt.t list
                    val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
                    val filter_map :
                      ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
                    val of_tree : Tree.t -> t
                    val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                    val of_hashtbl_keys :
                      (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                    val of_map_keys :
                      (Elt.t, 'a, comparator_witness)
                      Core_kernel__.Core_set_intf.Map.t -> t
                    val gen :
                      Elt.t Core_kernel__.Quickcheck.Generator.t ->
                      t Core_kernel__.Quickcheck.Generator.t
                    module Provide_of_sexp :
                      functor
                        (Elt : sig
                                 val t_of_sexp : Sexplib.Sexp.t -> Elt.t
                               end->
                        sig val t_of_sexp : Sexplib.Sexp.t -> t end
                    module Provide_bin_io :
                      functor
                        (Elt : sig
                                 val bin_t : Elt.t Bin_prot.Type_class.t
                                 val bin_read_t : Elt.t Bin_prot.Read.reader
                                 val __bin_read_t__ :
                                   (Core_kernel__.Import.int -> Elt.t)
                                   Bin_prot.Read.reader
                                 val bin_reader_t :
                                   Elt.t Bin_prot.Type_class.reader
                                 val bin_size_t : Elt.t Bin_prot.Size.sizer
                                 val bin_write_t :
                                   Elt.t Bin_prot.Write.writer
                                 val bin_writer_t :
                                   Elt.t Bin_prot.Type_class.writer
                                 val bin_shape_t : Bin_prot.Shape.t
                               end->
                        sig
                          val bin_size_t : t Bin_prot.Size.sizer
                          val bin_write_t : t Bin_prot.Write.writer
                          val bin_read_t : t Bin_prot.Read.reader
                          val __bin_read_t__ :
                            (int -> t) Bin_prot.Read.reader
                          val bin_shape_t : Bin_prot.Shape.t
                          val bin_writer_t : t Bin_prot.Type_class.writer
                          val bin_reader_t : t Bin_prot.Type_class.reader
                          val bin_t : t Bin_prot.Type_class.t
                        end
                    module Provide_hash :
                      functor
                        (Elt : sig
                                 val hash_fold_t :
                                   Base__.Hash.state ->
                                   Elt.t -> Base__.Hash.state
                               end->
                        sig
                          val hash_fold_t :
                            Ppx_hash_lib.Std.Hash.state ->
                            t -> Ppx_hash_lib.Std.Hash.state
                          val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                        end
                    val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                    val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  end
                val hash : t -> Core_kernel__.Import.int
                val compare : t -> t -> Core_kernel__.Import.int
                val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
                module Table :
                  sig
                    type key = t
                    type ('a, 'b) hashtbl = ('a, 'b) Edge.Table.hashtbl
                    type 'b t = (key, 'b) hashtbl
                    val sexp_of_t :
                      ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                    type ('a, 'b) t_ = 'b t
                    type 'a key_ = key
                    val hashable :
                      key Core_kernel__.Core_hashtbl_intf.Hashable.t
                    val invariant :
                      'Base__.Invariant_intf.inv ->
                      'a t Base__.Invariant_intf.inv
                    val create :
                      (key, 'b, unit -> 'b t)
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val of_alist :
                      (key, 'b,
                       (key * 'b) list ->
                       [ `Duplicate_key of key | `Ok of 'b t ])
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val of_alist_report_all_dups :
                      (key, 'b,
                       (key * 'b) list ->
                       [ `Duplicate_keys of key list | `Ok of 'b t ])
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val of_alist_or_error :
                      (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val of_alist_exn :
                      (key, 'b, (key * 'b) list -> 'b t)
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val of_alist_multi :
                      (key, 'b list, (key * 'b) list -> 'b list t)
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val create_mapped :
                      (key, 'b,
                       get_key:('-> key) ->
                       get_data:('-> 'b) ->
                       'r list ->
                       [ `Duplicate_keys of key list | `Ok of 'b t ])
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val create_with_key :
                      (key, 'r,
                       get_key:('-> key) ->
                       'r list ->
                       [ `Duplicate_keys of key list | `Ok of 'r t ])
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val create_with_key_or_error :
                      (key, 'r,
                       get_key:('-> key) ->
                       'r list -> 'r t Base__.Or_error.t)
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val create_with_key_exn :
                      (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val group :
                      (key, 'b,
                       get_key:('-> key) ->
                       get_data:('-> 'b) ->
                       combine:('-> '-> 'b) -> 'r list -> 'b t)
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                    val clear : 'a t -> unit
                    val copy : 'b t -> 'b t
                    val fold :
                      'b t ->
                      init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                    val iter_keys : 'a t -> f:(key -> unit) -> unit
                    val iter : 'b t -> f:('-> unit) -> unit
                    val iteri :
                      'b t -> f:(key:key -> data:'-> unit) -> unit
                    val iter_vals : 'b t -> f:('-> unit) -> unit
                    val existsi :
                      'b t -> f:(key:key -> data:'-> bool) -> bool
                    val exists : 'b t -> f:('-> bool) -> bool
                    val for_alli :
                      'b t -> f:(key:key -> data:'-> bool) -> bool
                    val for_all : 'b t -> f:('-> bool) -> bool
                    val counti :
                      'b t -> f:(key:key -> data:'-> bool) -> int
                    val count : 'b t -> f:('-> bool) -> int
                    val length : 'a t -> int
                    val is_empty : 'a t -> bool
                    val mem : 'a t -> key -> bool
                    val remove : 'a t -> key -> unit
                    val replace : 'b t -> key:key -> data:'-> unit
                    val set : 'b t -> key:key -> data:'-> unit
                    val add :
                      'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                    val add_or_error :
                      'b t -> key:key -> data:'-> unit Base__.Or_error.t
                    val add_exn : 'b t -> key:key -> data:'-> unit
                    val change :
                      'b t -> key -> f:('b option -> 'b option) -> unit
                    val update : 'b t -> key -> f:('b option -> 'b) -> unit
                    val add_multi : 'b list t -> key:key -> data:'-> unit
                    val remove_multi : 'a list t -> key -> unit
                    val map : 'b t -> f:('-> 'c) -> 'c t
                    val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                    val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                    val filter_mapi :
                      'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                    val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                    val filter : 'b t -> f:('-> bool) -> 'b t
                    val filteri :
                      'b t -> f:(key:key -> data:'-> bool) -> 'b t
                    val partition_map :
                      'b t ->
                      f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                    val partition_mapi :
                      'b t ->
                      f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                      'c t * 'd t
                    val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
                    val partitioni_tf :
                      'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                    val find_or_add :
                      'b t -> key -> default:(unit -> 'b) -> 'b
                    val find : 'b t -> key -> 'b option
                    val find_exn : 'b t -> key -> 'b
                    val find_and_call :
                      'b t ->
                      key ->
                      if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                    val find_and_remove : 'b t -> key -> 'b option
                    val merge :
                      'a t ->
                      'b t ->
                      f:(key:key ->
                         [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                         'c option) ->
                      'c t
                    type 'a merge_into_action = Remove | Set_to of 'a
                    val merge_into :
                      src:'a t ->
                      dst:'b t ->
                      f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                      unit
                    val keys : 'a t -> key list
                    val data : 'b t -> 'b list
                    val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
                    val filter_inplace : 'b t -> f:('-> bool) -> unit
                    val filteri_inplace :
                      'b t -> f:(key:key -> data:'-> bool) -> unit
                    val map_inplace : 'b t -> f:('-> 'b) -> unit
                    val mapi_inplace :
                      'b t -> f:(key:key -> data:'-> 'b) -> unit
                    val filter_map_inplace :
                      'b t -> f:('-> 'b option) -> unit
                    val filter_mapi_inplace :
                      'b t -> f:(key:key -> data:'-> 'b option) -> unit
                    val replace_all : 'b t -> f:('-> 'b) -> unit
                    val replace_alli :
                      'b t -> f:(key:key -> data:'-> 'b) -> unit
                    val filter_replace_all :
                      'b t -> f:('-> 'b option) -> unit
                    val filter_replace_alli :
                      'b t -> f:(key:key -> data:'-> 'b option) -> unit
                    val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                    val similar :
                      'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                    val to_alist : 'b t -> (key * 'b) list
                    val validate :
                      name:(key -> string) ->
                      'Base__.Validate.check -> 'b t Base__.Validate.check
                    val incr :
                      ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                    val decr :
                      ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                    module Provide_of_sexp :
                      functor
                        (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                        sig
                          val t_of_sexp :
                            (Sexplib.Sexp.t -> 'v_x__001_) ->
                            Sexplib.Sexp.t -> 'v_x__001_ t
                        end
                    module Provide_bin_io :
                      functor
                        (Key : sig
                                 val bin_t : key Bin_prot.Type_class.t
                                 val bin_read_t : key Bin_prot.Read.reader
                                 val __bin_read_t__ :
                                   (Core_kernel__.Import.int -> key)
                                   Bin_prot.Read.reader
                                 val bin_reader_t :
                                   key Bin_prot.Type_class.reader
                                 val bin_size_t : key Bin_prot.Size.sizer
                                 val bin_write_t : key Bin_prot.Write.writer
                                 val bin_writer_t :
                                   key Bin_prot.Type_class.writer
                                 val bin_shape_t : Bin_prot.Shape.t
                               end->
                        sig
                          val bin_t :
                            'Bin_prot.Type_class.t ->
                            'a t Bin_prot.Type_class.t
                          val bin_read_t :
                            'Bin_prot.Read.reader ->
                            'a t Bin_prot.Read.reader
                          val __bin_read_t__ :
                            'Bin_prot.Read.reader ->
                            (Core_kernel__.Import.int -> 'a t)
                            Bin_prot.Read.reader
                          val bin_reader_t :
                            'Bin_prot.Type_class.reader ->
                            'a t Bin_prot.Type_class.reader
                          val bin_size_t :
                            'Bin_prot.Size.sizer ->
                            'a t Bin_prot.Size.sizer
                          val bin_write_t :
                            'Bin_prot.Write.writer ->
                            'a t Bin_prot.Write.writer
                          val bin_writer_t :
                            'Bin_prot.Type_class.writer ->
                            'a t Bin_prot.Type_class.writer
                          val bin_shape_t :
                            Bin_prot.Shape.t -> Bin_prot.Shape.t
                        end
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__002_) ->
                      Sexplib.Sexp.t -> 'v_x__002_ t
                  end
                module Hash_set :
                  sig
                    type elt = t
                    type t = elt Core_kernel__.Hash_set.t
                    val sexp_of_t : t -> Sexplib.Sexp.t
                    type 'a t_ = t
                    type 'a elt_ = elt
                    val create :
                      ('a, unit -> t)
                      Core_kernel__.Hash_set_intf.create_options_without_hashable
                    val of_list :
                      ('a, elt list -> t)
                      Core_kernel__.Hash_set_intf.create_options_without_hashable
                    module Provide_of_sexp :
                      functor
                        (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                        sig val t_of_sexp : Sexplib.Sexp.t -> t end
                    module Provide_bin_io :
                      functor
                        (X : sig
                               val bin_t : elt Bin_prot.Type_class.t
                               val bin_read_t : elt Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> elt)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 elt Bin_prot.Type_class.reader
                               val bin_size_t : elt Bin_prot.Size.sizer
                               val bin_write_t : elt Bin_prot.Write.writer
                               val bin_writer_t :
                                 elt Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                        sig
                          val bin_t : t Bin_prot.Type_class.t
                          val bin_read_t : t Bin_prot.Read.reader
                          val __bin_read_t__ :
                            (Core_kernel__.Import.int -> t)
                            Bin_prot.Read.reader
                          val bin_reader_t : t Bin_prot.Type_class.reader
                          val bin_size_t : t Bin_prot.Size.sizer
                          val bin_write_t : t Bin_prot.Write.writer
                          val bin_writer_t : t Bin_prot.Type_class.writer
                          val bin_shape_t : Bin_prot.Shape.t
                        end
                    val t_of_sexp : Sexplib.Sexp.t -> t
                  end
                module Hash_queue :
                  sig
                    module Key :
                      sig
                        type t = Hash_set.elt
                        val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                        val compare : t -> t -> int
                        val hash : t -> int
                      end
                    type 'a t
                    val sexp_of_t :
                      ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                    val length : 'a t -> int
                    val is_empty : 'a t -> bool
                    val iter : 'a t -> f:('-> unit) -> unit
                    val fold :
                      'a t ->
                      init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                    val fold_result :
                      'a t ->
                      init:'accum ->
                      f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                      ('accum, 'e) Base__.Result.t
                    val fold_until :
                      'a t ->
                      init:'accum ->
                      f:('accum ->
                         '->
                         ('accum, 'stop)
                         Base.Container_intf.Continue_or_stop.t) ->
                      ('accum, 'stop)
                      Base.Container_intf.Finished_or_stopped_early.t
                    val exists : 'a t -> f:('-> bool) -> bool
                    val for_all : 'a t -> f:('-> bool) -> bool
                    val count : 'a t -> f:('-> bool) -> int
                    val sum :
                      (module Base__.Commutative_group.S with type t = 'sum) ->
                      'a t -> f:('-> 'sum) -> 'sum
                    val find : 'a t -> f:('-> bool) -> 'a option
                    val find_map : 'a t -> f:('-> 'b option) -> 'b option
                    val to_list : 'a t -> 'a list
                    val to_array : 'a t -> 'a array
                    val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
                    val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
                    val invariant : 'a t -> Core_kernel__.Import.unit
                    val create :
                      ?growth_allowed:Core_kernel__.Import.bool ->
                      ?size:Core_kernel__.Import.int ->
                      Core_kernel__.Import.unit -> 'a t
                    val clear : 'a t -> Core_kernel__.Import.unit
                    val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
                    val lookup :
                      'a t -> Key.t -> 'Core_kernel__.Import.option
                    val lookup_exn : 'a t -> Key.t -> 'a
                    val enqueue :
                      'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
                    val enqueue_exn :
                      'a t -> Key.t -> '-> Core_kernel__.Import.unit
                    val lookup_and_move_to_back :
                      'a t -> Key.t -> 'Core_kernel__.Import.option
                    val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
                    val first : 'a t -> 'Core_kernel__.Import.option
                    val first_with_key :
                      'a t -> (Key.t * 'a) Core_kernel__.Import.option
                    val keys : 'a t -> Key.t Core_kernel__.Import.list
                    val dequeue : 'a t -> 'Core_kernel__.Import.option
                    val dequeue_exn : 'a t -> 'a
                    val dequeue_with_key :
                      'a t -> (Key.t * 'a) Core_kernel__.Import.option
                    val dequeue_with_key_exn : 'a t -> Key.t * 'a
                    val dequeue_all :
                      'a t ->
                      f:('-> Core_kernel__.Import.unit) ->
                      Core_kernel__.Import.unit
                    val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
                    val remove_exn :
                      'a t -> Key.t -> Core_kernel__.Import.unit
                    val replace :
                      'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
                    val replace_exn :
                      'a t -> Key.t -> '-> Core_kernel__.Import.unit
                    val iteri :
                      'a t ->
                      f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                      Core_kernel__.Import.unit
                    val foldi :
                      'a t ->
                      init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
                  end
                val to_string : t -> string
                val str : unit -> t -> string
                val pps : unit -> t -> string
                val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
                val pp_seq :
                  Format.formatter -> t Core_kernel.Std.Sequence.t -> unit
                val pp : Base__.Import.Caml.Format.formatter -> t -> unit
              end
          module Filtered :
            functor
              (G : Graph) (P : sig
                                 type edge = G.edge
                                 type node = G.node
                                 val edge : edge -> bool
                                 val node : node -> bool
                               end->
              sig
                type t = G.t
                type node = P.node
                type edge = P.edge
                module Node :
                  sig
                    type t = node
                    type graph = G.t
                    type label = G.Node.label
                    type edge = P.edge
                    val create : label -> t
                    val label : t -> label
                    val mem : t -> graph -> bool
                    val succs : t -> graph -> t Regular.Std.seq
                    val preds : t -> graph -> t Regular.Std.seq
                    val inputs : t -> graph -> edge Regular.Std.seq
                    val outputs : t -> graph -> edge Regular.Std.seq
                    val degree : ?dir:[ `In | `Out ] -> t -> graph -> int
                    val insert : t -> graph -> graph
                    val update : t -> label -> graph -> graph
                    val remove : t -> graph -> graph
                    val has_edge : t -> t -> graph -> bool
                    val edge : t -> t -> graph -> edge option
                    val ( >= ) : t -> t -> bool
                    val ( <= ) : t -> t -> bool
                    val ( = ) : t -> t -> bool
                    val ( > ) : t -> t -> bool
                    val ( < ) : t -> t -> bool
                    val ( <> ) : t -> t -> bool
                    val equal : t -> t -> bool
                    val min : t -> t -> t
                    val max : t -> t -> t
                    val ascending : t -> t -> int
                    val descending : t -> t -> int
                    val between : t -> low:t -> high:t -> bool
                    val clamp_exn : t -> min:t -> max:t -> t
                    val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
                    type comparator_witness = G.Node.comparator_witness
                    val comparator :
                      (t, comparator_witness) Base__.Comparator.comparator
                    val validate_lbound :
                      min:t Base__.Maybe_bound.t -> t Base__.Validate.check
                    val validate_ubound :
                      max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                    val validate_bound :
                      min:t Base__.Maybe_bound.t ->
                      max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                    module Replace_polymorphic_compare :
                      sig
                        val ( >= ) : t -> t -> bool
                        val ( <= ) : t -> t -> bool
                        val ( = ) : t -> t -> bool
                        val ( > ) : t -> t -> bool
                        val ( < ) : t -> t -> bool
                        val ( <> ) : t -> t -> bool
                        val equal : t -> t -> bool
                        val compare : t -> t -> int
                        val min : t -> t -> t
                        val max : t -> t -> t
                      end
                    module Map :
                      sig
                        module Key :
                          sig
                            type t = node
                            val t_of_sexp : Sexplib.Sexp.t -> t
                            val sexp_of_t : t -> Sexplib.Sexp.t
                            type comparator_witness =
                                G.Node.comparator_witness
                            val comparator :
                              (t, comparator_witness)
                              Core_kernel__.Comparator.comparator
                          end
                        module Tree :
                          sig
                            type 'a t =
                                (node, 'a, comparator_witness)
                                Core_kernel__.Core_map_intf.Tree.t
                            val empty : 'a t
                            val singleton : node -> '-> 'a t
                            val of_alist :
                              (node * 'a) list ->
                              [ `Duplicate_key of node | `Ok of 'a t ]
                            val of_alist_or_error :
                              (node * 'a) list -> 'a t Base__.Or_error.t
                            val of_alist_exn : (node * 'a) list -> 'a t
                            val of_alist_multi :
                              (node * 'a) list -> 'a list t
                            val of_alist_fold :
                              (node * 'a) list ->
                              init:'-> f:('-> '-> 'b) -> 'b t
                            val of_alist_reduce :
                              (node * 'a) list -> f:('-> '-> 'a) -> 'a t
                            val of_sorted_array :
                              (node * 'a) array -> 'a t Base__.Or_error.t
                            val of_sorted_array_unchecked :
                              (node * 'a) array -> 'a t
                            val of_increasing_iterator_unchecked :
                              len:int -> f:(int -> node * 'a) -> 'a t
                            val of_iteri :
                              iteri:(f:(key:node -> data:'-> unit) -> unit) ->
                              [ `Duplicate_key of node | `Ok of 'v t ]
                            val of_tree : 'a t -> 'a t
                            val of_hashtbl_exn :
                              (node, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                            val gen :
                              node Core_kernel__.Quickcheck.Generator.t ->
                              'Core_kernel__.Quickcheck.Generator.t ->
                              'a t Core_kernel__.Quickcheck.Generator.t
                            val invariants : 'a t -> bool
                            val is_empty : 'a t -> bool
                            val length : 'a t -> int
                            val add : 'a t -> key:node -> data:'-> 'a t
                            val add_multi :
                              'a list t -> key:node -> data:'-> 'a list t
                            val remove_multi : 'a list t -> node -> 'a list t
                            val change :
                              'a t ->
                              node -> f:('a option -> 'a option) -> 'a t
                            val update :
                              'a t -> node -> f:('a option -> 'a) -> 'a t
                            val find : 'a t -> node -> 'a option
                            val find_exn : 'a t -> node -> 'a
                            val remove : 'a t -> node -> 'a t
                            val mem : 'a t -> node -> bool
                            val iter_keys : 'a t -> f:(node -> unit) -> unit
                            val iter : 'a t -> f:('-> unit) -> unit
                            val iteri :
                              'a t -> f:(key:node -> data:'-> unit) -> unit
                            val iter2 :
                              'a t ->
                              'b t ->
                              f:(key:node ->
                                 data:[ `Both of 'a * 'b
                                      | `Left of 'a
                                      | `Right of 'b ] ->
                                 unit) ->
                              unit
                            val map : 'a t -> f:('-> 'b) -> 'b t
                            val mapi :
                              'a t -> f:(key:node -> data:'-> 'b) -> 'b t
                            val fold :
                              'a t ->
                              init:'->
                              f:(key:node -> data:'-> '-> 'b) -> 'b
                            val fold_right :
                              'a t ->
                              init:'->
                              f:(key:node -> data:'-> '-> 'b) -> 'b
                            val fold2 :
                              'a t ->
                              'b t ->
                              init:'->
                              f:(key:node ->
                                 data:[ `Both of 'a * 'b
                                      | `Left of 'a
                                      | `Right of 'b ] ->
                                 '-> 'c) ->
                              'c
                            val filter_keys :
                              'a t -> f:(node -> bool) -> 'a t
                            val filter : 'a t -> f:('-> bool) -> 'a t
                            val filteri :
                              'a t -> f:(key:node -> data:'-> bool) -> 'a t
                            val filter_map :
                              'a t -> f:('-> 'b option) -> 'b t
                            val filter_mapi :
                              'a t ->
                              f:(key:node -> data:'-> 'b option) -> 'b t
                            val partition_mapi :
                              'a t ->
                              f:(key:node ->
                                 data:'-> [ `Fst of '| `Snd of 'c ]) ->
                              'b t * 'c t
                            val partition_map :
                              'a t ->
                              f:('-> [ `Fst of '| `Snd of 'c ]) ->
                              'b t * 'c t
                            val partitioni_tf :
                              'a t ->
                              f:(key:node -> data:'-> bool) -> 'a t * 'a t
                            val partition_tf :
                              'a t -> f:('-> bool) -> 'a t * 'a t
                            val compare_direct :
                              ('-> '-> int) -> 'a t -> 'a t -> int
                            val equal :
                              ('-> '-> bool) -> 'a t -> 'a t -> bool
                            val keys : 'a t -> node list
                            val data : 'a t -> 'a list
                            val to_alist :
                              ?key_order:[ `Decreasing | `Increasing ] ->
                              'a t -> (node * 'a) list
                            val validate :
                              name:(node -> string) ->
                              'Base__.Validate.check ->
                              'a t Base__.Validate.check
                            val merge :
                              'a t ->
                              'b t ->
                              f:(key:node ->
                                 [ `Both of 'a * 'b
                                 | `Left of 'a
                                 | `Right of 'b ] -> 'c option) ->
                              'c t
                            val symmetric_diff :
                              'a t ->
                              'a t ->
                              data_equal:('-> '-> bool) ->
                              (node, 'a)
                              Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                              Base__.Sequence.t
                            val min_elt : 'a t -> (node * 'a) option
                            val min_elt_exn : 'a t -> node * 'a
                            val max_elt : 'a t -> (node * 'a) option
                            val max_elt_exn : 'a t -> node * 'a
                            val for_all : 'a t -> f:('-> bool) -> bool
                            val for_alli :
                              'a t -> f:(key:node -> data:'-> bool) -> bool
                            val exists : 'a t -> f:('-> bool) -> bool
                            val existsi :
                              'a t -> f:(key:node -> data:'-> bool) -> bool
                            val count : 'a t -> f:('-> bool) -> int
                            val counti :
                              'a t -> f:(key:node -> data:'-> bool) -> int
                            val split :
                              'a t ->
                              node -> 'a t * (node * 'a) option * 'a t
                            val append :
                              lower_part:'a t ->
                              upper_part:'a t ->
                              [ `Ok of 'a t | `Overlapping_key_ranges ]
                            val subrange :
                              'a t ->
                              lower_bound:node Base__.Maybe_bound.t ->
                              upper_bound:node Base__.Maybe_bound.t -> 'a t
                            val fold_range_inclusive :
                              'a t ->
                              min:node ->
                              max:node ->
                              init:'->
                              f:(key:node -> data:'-> '-> 'b) -> 'b
                            val range_to_alist :
                              'a t ->
                              min:node -> max:node -> (node * 'a) list
                            val closest_key :
                              'a t ->
                              [ `Greater_or_equal_to
                              | `Greater_than
                              | `Less_or_equal_to
                              | `Less_than ] -> node -> (node * 'a) option
                            val nth : 'a t -> int -> (node * 'a) option
                            val nth_exn : 'a t -> int -> node * 'a
                            val rank : 'a t -> node -> int option
                            val to_tree : 'a t -> 'a t
                            val to_sequence :
                              ?order:[ `Decreasing_key | `Increasing_key ] ->
                              ?keys_greater_or_equal_to:node ->
                              ?keys_less_or_equal_to:node ->
                              'a t -> (node * 'a) Base__.Sequence.t
                            val obs :
                              node Core_kernel__.Quickcheck.Observer.t ->
                              'Core_kernel__.Quickcheck.Observer.t ->
                              'v t Core_kernel__.Quickcheck.Observer.t
                            val shrinker :
                              node Core_kernel__.Quickcheck.Shrinker.t ->
                              'Core_kernel__.Quickcheck.Shrinker.t ->
                              'v t Core_kernel__.Quickcheck.Shrinker.t
                            module Provide_of_sexp :
                              functor
                                (K : sig
                                       val t_of_sexp : Sexplib.Sexp.t -> node
                                     end->
                                sig
                                  val t_of_sexp :
                                    (Sexplib.Sexp.t -> 'v_x__017_) ->
                                    Sexplib.Sexp.t -> 'v_x__017_ t
                                end
                            val t_of_sexp :
                              (Base__.Sexplib.Sexp.t -> 'a) ->
                              Base__.Sexplib.Sexp.t -> 'a t
                            val sexp_of_t :
                              ('-> Base__.Sexplib.Sexp.t) ->
                              'a t -> Base__.Sexplib.Sexp.t
                          end
                        type 'a t =
                            (node, 'a, comparator_witness)
                            Core_kernel__.Core_map_intf.Map.t
                        val compare :
                          ('-> '-> Core_kernel__.Import.int) ->
                          'a t -> 'a t -> Core_kernel__.Import.int
                        val empty : 'a t
                        val singleton : node -> '-> 'a t
                        val of_alist :
                          (node * 'a) list ->
                          [ `Duplicate_key of node | `Ok of 'a t ]
                        val of_alist_or_error :
                          (node * 'a) list -> 'a t Base__.Or_error.t
                        val of_alist_exn : (node * 'a) list -> 'a t
                        val of_alist_multi : (node * 'a) list -> 'a list t
                        val of_alist_fold :
                          (node * 'a) list ->
                          init:'-> f:('-> '-> 'b) -> 'b t
                        val of_alist_reduce :
                          (node * 'a) list -> f:('-> '-> 'a) -> 'a t
                        val of_sorted_array :
                          (node * 'a) array -> 'a t Base__.Or_error.t
                        val of_sorted_array_unchecked :
                          (node * 'a) array -> 'a t
                        val of_increasing_iterator_unchecked :
                          len:int -> f:(int -> node * 'a) -> 'a t
                        val of_iteri :
                          iteri:(f:(key:node -> data:'-> unit) -> unit) ->
                          [ `Duplicate_key of node | `Ok of 'v t ]
                        val of_tree : 'Tree.t -> 'a t
                        val of_hashtbl_exn :
                          (node, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                        val gen :
                          node Core_kernel__.Quickcheck.Generator.t ->
                          'Core_kernel__.Quickcheck.Generator.t ->
                          'a t Core_kernel__.Quickcheck.Generator.t
                        val invariants : 'a t -> bool
                        val is_empty : 'a t -> bool
                        val length : 'a t -> int
                        val add : 'a t -> key:node -> data:'-> 'a t
                        val add_multi :
                          'a list t -> key:node -> data:'-> 'a list t
                        val remove_multi : 'a list t -> node -> 'a list t
                        val change :
                          'a t -> node -> f:('a option -> 'a option) -> 'a t
                        val update :
                          'a t -> node -> f:('a option -> 'a) -> 'a t
                        val find : 'a t -> node -> 'a option
                        val find_exn : 'a t -> node -> 'a
                        val remove : 'a t -> node -> 'a t
                        val mem : 'a t -> node -> bool
                        val iter_keys : 'a t -> f:(node -> unit) -> unit
                        val iter : 'a t -> f:('-> unit) -> unit
                        val iteri :
                          'a t -> f:(key:node -> data:'-> unit) -> unit
                        val iter2 :
                          'a t ->
                          'b t ->
                          f:(key:node ->
                             data:[ `Both of 'a * 'b
                                  | `Left of 'a
                                  | `Right of 'b ] ->
                             unit) ->
                          unit
                        val map : 'a t -> f:('-> 'b) -> 'b t
                        val mapi :
                          'a t -> f:(key:node -> data:'-> 'b) -> 'b t
                        val fold :
                          'a t ->
                          init:'->
                          f:(key:node -> data:'-> '-> 'b) -> 'b
                        val fold_right :
                          'a t ->
                          init:'->
                          f:(key:node -> data:'-> '-> 'b) -> 'b
                        val fold2 :
                          'a t ->
                          'b t ->
                          init:'->
                          f:(key:node ->
                             data:[ `Both of 'a * 'b
                                  | `Left of 'a
                                  | `Right of 'b ] ->
                             '-> 'c) ->
                          'c
                        val filter_keys : 'a t -> f:(node -> bool) -> 'a t
                        val filter : 'a t -> f:('-> bool) -> 'a t
                        val filteri :
                          'a t -> f:(key:node -> data:'-> bool) -> 'a t
                        val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                        val filter_mapi :
                          'a t ->
                          f:(key:node -> data:'-> 'b option) -> 'b t
                        val partition_mapi :
                          'a t ->
                          f:(key:node ->
                             data:'-> [ `Fst of '| `Snd of 'c ]) ->
                          'b t * 'c t
                        val partition_map :
                          'a t ->
                          f:('-> [ `Fst of '| `Snd of 'c ]) ->
                          'b t * 'c t
                        val partitioni_tf :
                          'a t ->
                          f:(key:node -> data:'-> bool) -> 'a t * 'a t
                        val partition_tf :
                          'a t -> f:('-> bool) -> 'a t * 'a t
                        val compare_direct :
                          ('-> '-> int) -> 'a t -> 'a t -> int
                        val equal :
                          ('-> '-> bool) -> 'a t -> 'a t -> bool
                        val keys : 'a t -> node list
                        val data : 'a t -> 'a list
                        val to_alist :
                          ?key_order:[ `Decreasing | `Increasing ] ->
                          'a t -> (node * 'a) list
                        val validate :
                          name:(node -> string) ->
                          'Base__.Validate.check ->
                          'a t Base__.Validate.check
                        val merge :
                          'a t ->
                          'b t ->
                          f:(key:node ->
                             [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                             'c option) ->
                          'c t
                        val symmetric_diff :
                          'a t ->
                          'a t ->
                          data_equal:('-> '-> bool) ->
                          (node, 'a)
                          Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                          Base__.Sequence.t
                        val min_elt : 'a t -> (node * 'a) option
                        val min_elt_exn : 'a t -> node * 'a
                        val max_elt : 'a t -> (node * 'a) option
                        val max_elt_exn : 'a t -> node * 'a
                        val for_all : 'a t -> f:('-> bool) -> bool
                        val for_alli :
                          'a t -> f:(key:node -> data:'-> bool) -> bool
                        val exists : 'a t -> f:('-> bool) -> bool
                        val existsi :
                          'a t -> f:(key:node -> data:'-> bool) -> bool
                        val count : 'a t -> f:('-> bool) -> int
                        val counti :
                          'a t -> f:(key:node -> data:'-> bool) -> int
                        val split :
                          'a t -> node -> 'a t * (node * 'a) option * 'a t
                        val append :
                          lower_part:'a t ->
                          upper_part:'a t ->
                          [ `Ok of 'a t | `Overlapping_key_ranges ]
                        val subrange :
                          'a t ->
                          lower_bound:node Base__.Maybe_bound.t ->
                          upper_bound:node Base__.Maybe_bound.t -> 'a t
                        val fold_range_inclusive :
                          'a t ->
                          min:node ->
                          max:node ->
                          init:'->
                          f:(key:node -> data:'-> '-> 'b) -> 'b
                        val range_to_alist :
                          'a t -> min:node -> max:node -> (node * 'a) list
                        val closest_key :
                          'a t ->
                          [ `Greater_or_equal_to
                          | `Greater_than
                          | `Less_or_equal_to
                          | `Less_than ] -> node -> (node * 'a) option
                        val nth : 'a t -> int -> (node * 'a) option
                        val nth_exn : 'a t -> int -> node * 'a
                        val rank : 'a t -> node -> int option
                        val to_tree : 'a t -> 'Tree.t
                        val to_sequence :
                          ?order:[ `Decreasing_key | `Increasing_key ] ->
                          ?keys_greater_or_equal_to:node ->
                          ?keys_less_or_equal_to:node ->
                          'a t -> (node * 'a) Base__.Sequence.t
                        val obs :
                          node Core_kernel__.Quickcheck.Observer.t ->
                          'Core_kernel__.Quickcheck.Observer.t ->
                          'v t Core_kernel__.Quickcheck.Observer.t
                        val shrinker :
                          node Core_kernel__.Quickcheck.Shrinker.t ->
                          'Core_kernel__.Quickcheck.Shrinker.t ->
                          'v t Core_kernel__.Quickcheck.Shrinker.t
                        module Provide_of_sexp :
                          functor
                            (Key : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> node
                                   end->
                            sig
                              val t_of_sexp :
                                (Sexplib.Sexp.t -> 'v_x__018_) ->
                                Sexplib.Sexp.t -> 'v_x__018_ t
                            end
                        module Provide_bin_io :
                          functor
                            (Key : sig
                                     val bin_t : node Bin_prot.Type_class.t
                                     val bin_read_t :
                                       node Bin_prot.Read.reader
                                     val __bin_read_t__ :
                                       (Core_kernel__.Import.int -> node)
                                       Bin_prot.Read.reader
                                     val bin_reader_t :
                                       node Bin_prot.Type_class.reader
                                     val bin_size_t :
                                       node Bin_prot.Size.sizer
                                     val bin_write_t :
                                       node Bin_prot.Write.writer
                                     val bin_writer_t :
                                       node Bin_prot.Type_class.writer
                                     val bin_shape_t : Bin_prot.Shape.t
                                   end->
                            sig
                              val bin_shape_t :
                                Bin_prot.Shape.t -> Bin_prot.Shape.t
                              val bin_size_t :
                                ('a, 'a t) Bin_prot.Size.sizer1
                              val bin_write_t :
                                ('a, 'a t) Bin_prot.Write.writer1
                              val bin_read_t :
                                ('a, 'a t) Bin_prot.Read.reader1
                              val __bin_read_t__ :
                                ('a, int -> 'a t) Bin_prot.Read.reader1
                              val bin_writer_t :
                                ('a, 'a t) Bin_prot.Type_class.S1.writer
                              val bin_reader_t :
                                ('a, 'a t) Bin_prot.Type_class.S1.reader
                              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                            end
                        module Provide_hash :
                          functor
                            (Key : sig
                                     val hash_fold_t :
                                       Base__.Hash.state ->
                                       node -> Base__.Hash.state
                                   end->
                            sig
                              val hash_fold_t :
                                (Ppx_hash_lib.Std.Hash.state ->
                                 '-> Ppx_hash_lib.Std.Hash.state) ->
                                Ppx_hash_lib.Std.Hash.state ->
                                'a t -> Ppx_hash_lib.Std.Hash.state
                            end
                        val t_of_sexp :
                          (Base__.Sexplib.Sexp.t -> 'a) ->
                          Base__.Sexplib.Sexp.t -> 'a t
                        val sexp_of_t :
                          ('-> Base__.Sexplib.Sexp.t) ->
                          'a t -> Base__.Sexplib.Sexp.t
                      end
                    module Set :
                      sig
                        module Elt :
                          sig
                            type t = node
                            val t_of_sexp : Sexplib.Sexp.t -> t
                            val sexp_of_t : t -> Sexplib.Sexp.t
                            type comparator_witness =
                                Map.Key.comparator_witness
                            val comparator :
                              (t, comparator_witness)
                              Core_kernel__.Comparator.comparator
                          end
                        module Tree :
                          sig
                            type t =
                                (node, comparator_witness)
                                Core_kernel__.Core_set_intf.Tree.t
                            val compare : t -> t -> Core_kernel__.Import.int
                            val length : t -> int
                            val is_empty : t -> bool
                            val iter : t -> f:(node -> unit) -> unit
                            val fold :
                              t ->
                              init:'accum ->
                              f:('accum -> node -> 'accum) -> 'accum
                            val fold_result :
                              t ->
                              init:'accum ->
                              f:('accum ->
                                 node -> ('accum, 'e) Base__.Result.t) ->
                              ('accum, 'e) Base__.Result.t
                            val exists : t -> f:(node -> bool) -> bool
                            val for_all : t -> f:(node -> bool) -> bool
                            val count : t -> f:(node -> bool) -> int
                            val sum :
                              (module Base__.Commutative_group.S with type t = 'sum) ->
                              t -> f:(node -> 'sum) -> 'sum
                            val find : t -> f:(node -> bool) -> node option
                            val find_map :
                              t -> f:(node -> 'a option) -> 'a option
                            val to_list : t -> node list
                            val to_array : t -> node array
                            val invariants : t -> bool
                            val mem : t -> node -> bool
                            val add : t -> node -> t
                            val remove : t -> node -> t
                            val union : t -> t -> t
                            val inter : t -> t -> t
                            val diff : t -> t -> t
                            val symmetric_diff :
                              t ->
                              t ->
                              (node, node) Base__.Either.t Base__.Sequence.t
                            val compare_direct : t -> t -> int
                            val equal : t -> t -> bool
                            val is_subset : t -> of_:t -> bool
                            val subset : t -> t -> bool
                            val fold_until :
                              t ->
                              init:'->
                              f:('->
                                 node ->
                                 ('b, 'stop)
                                 Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                              ('b, 'stop)
                              Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                            val fold_right :
                              t -> init:'-> f:(node -> '-> 'b) -> 'b
                            val iter2 :
                              t ->
                              t ->
                              f:([ `Both of node * node
                                 | `Left of node
                                 | `Right of node ] -> unit) ->
                              unit
                            val filter : t -> f:(node -> bool) -> t
                            val partition_tf : t -> f:(node -> bool) -> t * t
                            val elements : t -> node list
                            val min_elt : t -> node option
                            val min_elt_exn : t -> node
                            val max_elt : t -> node option
                            val max_elt_exn : t -> node
                            val choose : t -> node option
                            val choose_exn : t -> node
                            val split : t -> node -> t * node option * t
                            val group_by :
                              t -> equiv:(node -> node -> bool) -> t list
                            val find_exn : t -> f:(node -> bool) -> node
                            val find_index : t -> int -> node option
                            val nth : t -> int -> node option
                            val remove_index : t -> int -> t
                            val to_tree : t -> t
                            val to_sequence :
                              ?order:[ `Decreasing | `Increasing ] ->
                              ?greater_or_equal_to:node ->
                              ?less_or_equal_to:node ->
                              t -> node Base__.Sequence.t
                            val merge_to_sequence :
                              ?order:[ `Decreasing | `Increasing ] ->
                              ?greater_or_equal_to:node ->
                              ?less_or_equal_to:node ->
                              t ->
                              t ->
                              (node, node)
                              Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                              Base__.Sequence.t
                            val to_map :
                              t ->
                              f:(node -> 'data) ->
                              (node, 'data, comparator_witness)
                              Core_kernel__.Core_set_intf.Map.t
                            val obs :
                              node Core_kernel__.Quickcheck.Observer.t ->
                              t Core_kernel__.Quickcheck.Observer.t
                            val shrinker :
                              node Core_kernel__.Quickcheck.Shrinker.t ->
                              t Core_kernel__.Quickcheck.Shrinker.t
                            val empty : t
                            val singleton : node -> t
                            val union_list : t list -> t
                            val of_list : node list -> t
                            val of_array : node array -> t
                            val of_sorted_array :
                              node array -> t Base__.Or_error.t
                            val of_sorted_array_unchecked : node array -> t
                            val of_increasing_iterator_unchecked :
                              len:int -> f:(int -> node) -> t
                            val stable_dedup_list : node list -> node list
                            val map :
                              ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                              f:('-> node) -> t
                            val filter_map :
                              ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                              f:('-> node option) -> t
                            val of_tree : t -> t
                            val of_hash_set :
                              node Core_kernel__.Hash_set.t -> t
                            val of_hashtbl_keys :
                              (node, 'a) Core_kernel__.Core_hashtbl.t -> t
                            val of_map_keys :
                              (node, 'a, comparator_witness)
                              Core_kernel__.Core_set_intf.Map.t -> t
                            val gen :
                              node Core_kernel__.Quickcheck.Generator.t ->
                              t Core_kernel__.Quickcheck.Generator.t
                            module Provide_of_sexp :
                              functor
                                (Elt : sig
                                         val t_of_sexp :
                                           Sexplib.Sexp.t -> node
                                       end->
                                sig val t_of_sexp : Sexplib.Sexp.t -> t end
                            val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                            val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                          end
                        type t = (node, comparator_witness) Base.Set.t
                        val compare : t -> t -> Core_kernel__.Import.int
                        val length : t -> int
                        val is_empty : t -> bool
                        val iter : t -> f:(node -> unit) -> unit
                        val fold :
                          t ->
                          init:'accum ->
                          f:('accum -> node -> 'accum) -> 'accum
                        val fold_result :
                          t ->
                          init:'accum ->
                          f:('accum -> node -> ('accum, 'e) Base__.Result.t) ->
                          ('accum, 'e) Base__.Result.t
                        val exists : t -> f:(node -> bool) -> bool
                        val for_all : t -> f:(node -> bool) -> bool
                        val count : t -> f:(node -> bool) -> int
                        val sum :
                          (module Base__.Commutative_group.S with type t = 'sum) ->
                          t -> f:(node -> 'sum) -> 'sum
                        val find : t -> f:(node -> bool) -> node option
                        val find_map :
                          t -> f:(node -> 'a option) -> 'a option
                        val to_list : t -> node list
                        val to_array : t -> node array
                        val invariants : t -> bool
                        val mem : t -> node -> bool
                        val add : t -> node -> t
                        val remove : t -> node -> t
                        val union : t -> t -> t
                        val inter : t -> t -> t
                        val diff : t -> t -> t
                        val symmetric_diff :
                          t ->
                          t -> (node, node) Base__.Either.t Base__.Sequence.t
                        val compare_direct : t -> t -> int
                        val equal : t -> t -> bool
                        val is_subset : t -> of_:t -> bool
                        val subset : t -> t -> bool
                        val fold_until :
                          t ->
                          init:'->
                          f:('->
                             node ->
                             ('b, 'stop)
                             Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                          ('b, 'stop)
                          Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                        val fold_right :
                          t -> init:'-> f:(node -> '-> 'b) -> 'b
                        val iter2 :
                          t ->
                          t ->
                          f:([ `Both of node * node
                             | `Left of node
                             | `Right of node ] -> unit) ->
                          unit
                        val filter : t -> f:(node -> bool) -> t
                        val partition_tf : t -> f:(node -> bool) -> t * t
                        val elements : t -> node list
                        val min_elt : t -> node option
                        val min_elt_exn : t -> node
                        val max_elt : t -> node option
                        val max_elt_exn : t -> node
                        val choose : t -> node option
                        val choose_exn : t -> node
                        val split : t -> node -> t * node option * t
                        val group_by :
                          t -> equiv:(node -> node -> bool) -> t list
                        val find_exn : t -> f:(node -> bool) -> node
                        val find_index : t -> int -> node option
                        val nth : t -> int -> node option
                        val remove_index : t -> int -> t
                        val to_tree : t -> Tree.t
                        val to_sequence :
                          ?order:[ `Decreasing | `Increasing ] ->
                          ?greater_or_equal_to:node ->
                          ?less_or_equal_to:node ->
                          t -> node Base__.Sequence.t
                        val merge_to_sequence :
                          ?order:[ `Decreasing | `Increasing ] ->
                          ?greater_or_equal_to:node ->
                          ?less_or_equal_to:node ->
                          t ->
                          t ->
                          (node, node)
                          Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                          Base__.Sequence.t
                        val to_map :
                          t ->
                          f:(node -> 'data) ->
                          (node, 'data, comparator_witness)
                          Core_kernel__.Core_set_intf.Map.t
                        val obs :
                          node Core_kernel__.Quickcheck.Observer.t ->
                          t Core_kernel__.Quickcheck.Observer.t
                        val shrinker :
                          node Core_kernel__.Quickcheck.Shrinker.t ->
                          t Core_kernel__.Quickcheck.Shrinker.t
                        val empty : t
                        val singleton : node -> t
                        val union_list : t list -> t
                        val of_list : node list -> t
                        val of_array : node array -> t
                        val of_sorted_array :
                          node array -> t Base__.Or_error.t
                        val of_sorted_array_unchecked : node array -> t
                        val of_increasing_iterator_unchecked :
                          len:int -> f:(int -> node) -> t
                        val stable_dedup_list : node list -> node list
                        val map : ('a, 'b) Base.Set.t -> f:('-> node) -> t
                        val filter_map :
                          ('a, 'b) Base.Set.t -> f:('-> node option) -> t
                        val of_tree : Tree.t -> t
                        val of_hash_set : node Core_kernel__.Hash_set.t -> t
                        val of_hashtbl_keys :
                          (node, 'a) Core_kernel__.Core_hashtbl.t -> t
                        val of_map_keys :
                          (node, 'a, comparator_witness)
                          Core_kernel__.Core_set_intf.Map.t -> t
                        val gen :
                          node Core_kernel__.Quickcheck.Generator.t ->
                          t Core_kernel__.Quickcheck.Generator.t
                        module Provide_of_sexp :
                          functor
                            (Elt : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> node
                                   end->
                            sig val t_of_sexp : Sexplib.Sexp.t -> t end
                        module Provide_bin_io :
                          functor
                            (Elt : sig
                                     val bin_t : node Bin_prot.Type_class.t
                                     val bin_read_t :
                                       node Bin_prot.Read.reader
                                     val __bin_read_t__ :
                                       (Core_kernel__.Import.int -> node)
                                       Bin_prot.Read.reader
                                     val bin_reader_t :
                                       node Bin_prot.Type_class.reader
                                     val bin_size_t :
                                       node Bin_prot.Size.sizer
                                     val bin_write_t :
                                       node Bin_prot.Write.writer
                                     val bin_writer_t :
                                       node Bin_prot.Type_class.writer
                                     val bin_shape_t : Bin_prot.Shape.t
                                   end->
                            sig
                              val bin_size_t : t Bin_prot.Size.sizer
                              val bin_write_t : t Bin_prot.Write.writer
                              val bin_read_t : t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                (int -> t) Bin_prot.Read.reader
                              val bin_shape_t : Bin_prot.Shape.t
                              val bin_writer_t : t Bin_prot.Type_class.writer
                              val bin_reader_t : t Bin_prot.Type_class.reader
                              val bin_t : t Bin_prot.Type_class.t
                            end
                        module Provide_hash :
                          functor
                            (Elt : sig
                                     val hash_fold_t :
                                       Base__.Hash.state ->
                                       node -> Base__.Hash.state
                                   end->
                            sig
                              val hash_fold_t :
                                Ppx_hash_lib.Std.Hash.state ->
                                t -> Ppx_hash_lib.Std.Hash.state
                              val hash :
                                t -> Ppx_hash_lib.Std.Hash.hash_value
                            end
                        val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                        val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                      end
                    val hash : t -> Core_kernel__.Import.int
                    val compare : t -> t -> Core_kernel__.Import.int
                    val hashable :
                      t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
                    module Table :
                      sig
                        type key = t
                        type ('a, 'b) hashtbl = ('a, 'b) G.Table.hashtbl
                        type 'b t = (key, 'b) hashtbl
                        val sexp_of_t :
                          ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                        type ('a, 'b) t_ = 'b t
                        type 'a key_ = key
                        val hashable :
                          key Core_kernel__.Core_hashtbl_intf.Hashable.t
                        val invariant :
                          'Base__.Invariant_intf.inv ->
                          'a t Base__.Invariant_intf.inv
                        val create :
                          (key, 'b, unit -> 'b t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist :
                          (key, 'b,
                           (key * 'b) list ->
                           [ `Duplicate_key of key | `Ok of 'b t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_report_all_dups :
                          (key, 'b,
                           (key * 'b) list ->
                           [ `Duplicate_keys of key list | `Ok of 'b t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_or_error :
                          (key, 'b,
                           (key * 'b) list -> 'b t Base__.Or_error.t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_exn :
                          (key, 'b, (key * 'b) list -> 'b t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_multi :
                          (key, 'b list, (key * 'b) list -> 'b list t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_mapped :
                          (key, 'b,
                           get_key:('-> key) ->
                           get_data:('-> 'b) ->
                           'r list ->
                           [ `Duplicate_keys of key list | `Ok of 'b t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_with_key :
                          (key, 'r,
                           get_key:('-> key) ->
                           'r list ->
                           [ `Duplicate_keys of key list | `Ok of 'r t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_with_key_or_error :
                          (key, 'r,
                           get_key:('-> key) ->
                           'r list -> 'r t Base__.Or_error.t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_with_key_exn :
                          (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val group :
                          (key, 'b,
                           get_key:('-> key) ->
                           get_data:('-> 'b) ->
                           combine:('-> '-> 'b) -> 'r list -> 'b t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                        val clear : 'a t -> unit
                        val copy : 'b t -> 'b t
                        val fold :
                          'b t ->
                          init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                        val iter_keys : 'a t -> f:(key -> unit) -> unit
                        val iter : 'b t -> f:('-> unit) -> unit
                        val iteri :
                          'b t -> f:(key:key -> data:'-> unit) -> unit
                        val iter_vals : 'b t -> f:('-> unit) -> unit
                        val existsi :
                          'b t -> f:(key:key -> data:'-> bool) -> bool
                        val exists : 'b t -> f:('-> bool) -> bool
                        val for_alli :
                          'b t -> f:(key:key -> data:'-> bool) -> bool
                        val for_all : 'b t -> f:('-> bool) -> bool
                        val counti :
                          'b t -> f:(key:key -> data:'-> bool) -> int
                        val count : 'b t -> f:('-> bool) -> int
                        val length : 'a t -> int
                        val is_empty : 'a t -> bool
                        val mem : 'a t -> key -> bool
                        val remove : 'a t -> key -> unit
                        val replace : 'b t -> key:key -> data:'-> unit
                        val set : 'b t -> key:key -> data:'-> unit
                        val add :
                          'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                        val add_or_error :
                          'b t ->
                          key:key -> data:'-> unit Base__.Or_error.t
                        val add_exn : 'b t -> key:key -> data:'-> unit
                        val change :
                          'b t -> key -> f:('b option -> 'b option) -> unit
                        val update :
                          'b t -> key -> f:('b option -> 'b) -> unit
                        val add_multi :
                          'b list t -> key:key -> data:'-> unit
                        val remove_multi : 'a list t -> key -> unit
                        val map : 'b t -> f:('-> 'c) -> 'c t
                        val mapi :
                          'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                        val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                        val filter_mapi :
                          'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                        val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                        val filter : 'b t -> f:('-> bool) -> 'b t
                        val filteri :
                          'b t -> f:(key:key -> data:'-> bool) -> 'b t
                        val partition_map :
                          'b t ->
                          f:('-> [ `Fst of '| `Snd of 'd ]) ->
                          'c t * 'd t
                        val partition_mapi :
                          'b t ->
                          f:(key:key ->
                             data:'-> [ `Fst of '| `Snd of 'd ]) ->
                          'c t * 'd t
                        val partition_tf :
                          'b t -> f:('-> bool) -> 'b t * 'b t
                        val partitioni_tf :
                          'b t ->
                          f:(key:key -> data:'-> bool) -> 'b t * 'b t
                        val find_or_add :
                          'b t -> key -> default:(unit -> 'b) -> 'b
                        val find : 'b t -> key -> 'b option
                        val find_exn : 'b t -> key -> 'b
                        val find_and_call :
                          'b t ->
                          key ->
                          if_found:('-> 'c) ->
                          if_not_found:(key -> 'c) -> 'c
                        val find_and_remove : 'b t -> key -> 'b option
                        val merge :
                          'a t ->
                          'b t ->
                          f:(key:key ->
                             [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                             'c option) ->
                          'c t
                        type 'a merge_into_action =
                          'G.Node.Table.merge_into_action =
                            Remove
                          | Set_to of 'a
                        val merge_into :
                          src:'a t ->
                          dst:'b t ->
                          f:(key:key ->
                             '-> 'b option -> 'b merge_into_action) ->
                          unit
                        val keys : 'a t -> key list
                        val data : 'b t -> 'b list
                        val filter_keys_inplace :
                          'a t -> f:(key -> bool) -> unit
                        val filter_inplace : 'b t -> f:('-> bool) -> unit
                        val filteri_inplace :
                          'b t -> f:(key:key -> data:'-> bool) -> unit
                        val map_inplace : 'b t -> f:('-> 'b) -> unit
                        val mapi_inplace :
                          'b t -> f:(key:key -> data:'-> 'b) -> unit
                        val filter_map_inplace :
                          'b t -> f:('-> 'b option) -> unit
                        val filter_mapi_inplace :
                          'b t -> f:(key:key -> data:'-> 'b option) -> unit
                        val replace_all : 'b t -> f:('-> 'b) -> unit
                        val replace_alli :
                          'b t -> f:(key:key -> data:'-> 'b) -> unit
                        val filter_replace_all :
                          'b t -> f:('-> 'b option) -> unit
                        val filter_replace_alli :
                          'b t -> f:(key:key -> data:'-> 'b option) -> unit
                        val equal :
                          'b t -> 'b t -> ('-> '-> bool) -> bool
                        val similar :
                          'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                        val to_alist : 'b t -> (key * 'b) list
                        val validate :
                          name:(key -> string) ->
                          'Base__.Validate.check ->
                          'b t Base__.Validate.check
                        val incr :
                          ?by:int ->
                          ?remove_if_zero:bool -> int t -> key -> unit
                        val decr :
                          ?by:int ->
                          ?remove_if_zero:bool -> int t -> key -> unit
                        module Provide_of_sexp :
                          functor
                            (Key : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> key
                                   end->
                            sig
                              val t_of_sexp :
                                (Sexplib.Sexp.t -> 'v_x__001_) ->
                                Sexplib.Sexp.t -> 'v_x__001_ t
                            end
                        module Provide_bin_io :
                          functor
                            (Key : sig
                                     val bin_t : key Bin_prot.Type_class.t
                                     val bin_read_t :
                                       key Bin_prot.Read.reader
                                     val __bin_read_t__ :
                                       (Core_kernel__.Import.int -> key)
                                       Bin_prot.Read.reader
                                     val bin_reader_t :
                                       key Bin_prot.Type_class.reader
                                     val bin_size_t : key Bin_prot.Size.sizer
                                     val bin_write_t :
                                       key Bin_prot.Write.writer
                                     val bin_writer_t :
                                       key Bin_prot.Type_class.writer
                                     val bin_shape_t : Bin_prot.Shape.t
                                   end->
                            sig
                              val bin_t :
                                'Bin_prot.Type_class.t ->
                                'a t Bin_prot.Type_class.t
                              val bin_read_t :
                                'Bin_prot.Read.reader ->
                                'a t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                'Bin_prot.Read.reader ->
                                (Core_kernel__.Import.int -> 'a t)
                                Bin_prot.Read.reader
                              val bin_reader_t :
                                'Bin_prot.Type_class.reader ->
                                'a t Bin_prot.Type_class.reader
                              val bin_size_t :
                                'Bin_prot.Size.sizer ->
                                'a t Bin_prot.Size.sizer
                              val bin_write_t :
                                'Bin_prot.Write.writer ->
                                'a t Bin_prot.Write.writer
                              val bin_writer_t :
                                'Bin_prot.Type_class.writer ->
                                'a t Bin_prot.Type_class.writer
                              val bin_shape_t :
                                Bin_prot.Shape.t -> Bin_prot.Shape.t
                            end
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__002_) ->
                          Sexplib.Sexp.t -> 'v_x__002_ t
                      end
                    module Hash_set :
                      sig
                        type elt = t
                        type t = elt Core_kernel__.Hash_set.t
                        val sexp_of_t : t -> Sexplib.Sexp.t
                        type 'a t_ = t
                        type 'a elt_ = elt
                        val create :
                          ('a, unit -> t)
                          Core_kernel__.Hash_set_intf.create_options_without_hashable
                        val of_list :
                          ('a, elt list -> t)
                          Core_kernel__.Hash_set_intf.create_options_without_hashable
                        module Provide_of_sexp :
                          functor
                            (X : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> elt
                                 end->
                            sig val t_of_sexp : Sexplib.Sexp.t -> t end
                        module Provide_bin_io :
                          functor
                            (X : sig
                                   val bin_t : elt Bin_prot.Type_class.t
                                   val bin_read_t : elt Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> elt)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     elt Bin_prot.Type_class.reader
                                   val bin_size_t : elt Bin_prot.Size.sizer
                                   val bin_write_t :
                                     elt Bin_prot.Write.writer
                                   val bin_writer_t :
                                     elt Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                            sig
                              val bin_t : t Bin_prot.Type_class.t
                              val bin_read_t : t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                (Core_kernel__.Import.int -> t)
                                Bin_prot.Read.reader
                              val bin_reader_t : t Bin_prot.Type_class.reader
                              val bin_size_t : t Bin_prot.Size.sizer
                              val bin_write_t : t Bin_prot.Write.writer
                              val bin_writer_t : t Bin_prot.Type_class.writer
                              val bin_shape_t : Bin_prot.Shape.t
                            end
                        val t_of_sexp : Sexplib.Sexp.t -> t
                      end
                    module Hash_queue :
                      sig
                        module Key :
                          sig
                            type t = node
                            val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                            val compare : t -> t -> int
                            val hash : t -> int
                          end
                        type 'a t = 'G.Node.Hash_queue.t
                        val sexp_of_t :
                          ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                        val length : 'a t -> int
                        val is_empty : 'a t -> bool
                        val iter : 'a t -> f:('-> unit) -> unit
                        val fold :
                          'a t ->
                          init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                        val fold_result :
                          'a t ->
                          init:'accum ->
                          f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                          ('accum, 'e) Base__.Result.t
                        val fold_until :
                          'a t ->
                          init:'accum ->
                          f:('accum ->
                             '->
                             ('accum, 'stop)
                             Base.Container_intf.Continue_or_stop.t) ->
                          ('accum, 'stop)
                          Base.Container_intf.Finished_or_stopped_early.t
                        val exists : 'a t -> f:('-> bool) -> bool
                        val for_all : 'a t -> f:('-> bool) -> bool
                        val count : 'a t -> f:('-> bool) -> int
                        val sum :
                          (module Base__.Commutative_group.S with type t = 'sum) ->
                          'a t -> f:('-> 'sum) -> 'sum
                        val find : 'a t -> f:('-> bool) -> 'a option
                        val find_map :
                          'a t -> f:('-> 'b option) -> 'b option
                        val to_list : 'a t -> 'a list
                        val to_array : 'a t -> 'a array
                        val min_elt :
                          'a t -> cmp:('-> '-> int) -> 'a option
                        val max_elt :
                          'a t -> cmp:('-> '-> int) -> 'a option
                        val invariant : 'a t -> Core_kernel__.Import.unit
                        val create :
                          ?growth_allowed:Core_kernel__.Import.bool ->
                          ?size:Core_kernel__.Import.int ->
                          Core_kernel__.Import.unit -> 'a t
                        val clear : 'a t -> Core_kernel__.Import.unit
                        val mem : 'a t -> node -> Core_kernel__.Import.bool
                        val lookup :
                          'a t -> node -> 'Core_kernel__.Import.option
                        val lookup_exn : 'a t -> node -> 'a
                        val enqueue :
                          'a t ->
                          node -> '-> [ `Key_already_present | `Ok ]
                        val enqueue_exn :
                          'a t -> node -> '-> Core_kernel__.Import.unit
                        val lookup_and_move_to_back :
                          'a t -> node -> 'Core_kernel__.Import.option
                        val lookup_and_move_to_back_exn : 'a t -> node -> 'a
                        val first : 'a t -> 'Core_kernel__.Import.option
                        val first_with_key :
                          'a t -> (node * 'a) Core_kernel__.Import.option
                        val keys : 'a t -> node Core_kernel__.Import.list
                        val dequeue : 'a t -> 'Core_kernel__.Import.option
                        val dequeue_exn : 'a t -> 'a
                        val dequeue_with_key :
                          'a t -> (node * 'a) Core_kernel__.Import.option
                        val dequeue_with_key_exn : 'a t -> node * 'a
                        val dequeue_all :
                          'a t ->
                          f:('-> Core_kernel__.Import.unit) ->
                          Core_kernel__.Import.unit
                        val remove : 'a t -> node -> [ `No_such_key | `Ok ]
                        val remove_exn :
                          'a t -> node -> Core_kernel__.Import.unit
                        val replace :
                          'a t -> node -> '-> [ `No_such_key | `Ok ]
                        val replace_exn :
                          'a t -> node -> '-> Core_kernel__.Import.unit
                        val iteri :
                          'a t ->
                          f:(key:node -> data:'-> Core_kernel__.Import.unit) ->
                          Core_kernel__.Import.unit
                        val foldi :
                          'a t ->
                          init:'->
                          f:('-> key:node -> data:'-> 'b) -> 'b
                      end
                  end
                module Edge :
                  sig
                    type t = edge
                    type node = Node.t
                    type graph = Node.graph
                    type label = G.Edge.label
                    val create : node -> node -> label -> t
                    val label : t -> label
                    val src : t -> node
                    val dst : t -> node
                    val mem : t -> graph -> bool
                    val insert : t -> graph -> graph
                    val update : t -> label -> graph -> graph
                    val remove : t -> graph -> graph
                    val ( >= ) : t -> t -> bool
                    val ( <= ) : t -> t -> bool
                    val ( = ) : t -> t -> bool
                    val ( > ) : t -> t -> bool
                    val ( < ) : t -> t -> bool
                    val ( <> ) : t -> t -> bool
                    val equal : t -> t -> bool
                    val min : t -> t -> t
                    val max : t -> t -> t
                    val ascending : t -> t -> int
                    val descending : t -> t -> int
                    val between : t -> low:t -> high:t -> bool
                    val clamp_exn : t -> min:t -> max:t -> t
                    val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
                    type comparator_witness = G.Edge.comparator_witness
                    val comparator :
                      (t, comparator_witness) Base__.Comparator.comparator
                    val validate_lbound :
                      min:t Base__.Maybe_bound.t -> t Base__.Validate.check
                    val validate_ubound :
                      max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                    val validate_bound :
                      min:t Base__.Maybe_bound.t ->
                      max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                    module Replace_polymorphic_compare :
                      sig
                        val ( >= ) : t -> t -> bool
                        val ( <= ) : t -> t -> bool
                        val ( = ) : t -> t -> bool
                        val ( > ) : t -> t -> bool
                        val ( < ) : t -> t -> bool
                        val ( <> ) : t -> t -> bool
                        val equal : t -> t -> bool
                        val compare : t -> t -> int
                        val min : t -> t -> t
                        val max : t -> t -> t
                      end
                    module Map :
                      sig
                        module Key :
                          sig
                            type t = edge
                            val t_of_sexp : Sexplib.Sexp.t -> t
                            val sexp_of_t : t -> Sexplib.Sexp.t
                            type comparator_witness =
                                G.Edge.comparator_witness
                            val comparator :
                              (t, comparator_witness)
                              Core_kernel__.Comparator.comparator
                          end
                        module Tree :
                          sig
                            type 'a t =
                                (edge, 'a, comparator_witness)
                                Core_kernel__.Core_map_intf.Tree.t
                            val empty : 'a t
                            val singleton : edge -> '-> 'a t
                            val of_alist :
                              (edge * 'a) list ->
                              [ `Duplicate_key of edge | `Ok of 'a t ]
                            val of_alist_or_error :
                              (edge * 'a) list -> 'a t Base__.Or_error.t
                            val of_alist_exn : (edge * 'a) list -> 'a t
                            val of_alist_multi :
                              (edge * 'a) list -> 'a list t
                            val of_alist_fold :
                              (edge * 'a) list ->
                              init:'-> f:('-> '-> 'b) -> 'b t
                            val of_alist_reduce :
                              (edge * 'a) list -> f:('-> '-> 'a) -> 'a t
                            val of_sorted_array :
                              (edge * 'a) array -> 'a t Base__.Or_error.t
                            val of_sorted_array_unchecked :
                              (edge * 'a) array -> 'a t
                            val of_increasing_iterator_unchecked :
                              len:int -> f:(int -> edge * 'a) -> 'a t
                            val of_iteri :
                              iteri:(f:(key:edge -> data:'-> unit) -> unit) ->
                              [ `Duplicate_key of edge | `Ok of 'v t ]
                            val of_tree : 'a t -> 'a t
                            val of_hashtbl_exn :
                              (edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                            val gen :
                              edge Core_kernel__.Quickcheck.Generator.t ->
                              'Core_kernel__.Quickcheck.Generator.t ->
                              'a t Core_kernel__.Quickcheck.Generator.t
                            val invariants : 'a t -> bool
                            val is_empty : 'a t -> bool
                            val length : 'a t -> int
                            val add : 'a t -> key:edge -> data:'-> 'a t
                            val add_multi :
                              'a list t -> key:edge -> data:'-> 'a list t
                            val remove_multi : 'a list t -> edge -> 'a list t
                            val change :
                              'a t ->
                              edge -> f:('a option -> 'a option) -> 'a t
                            val update :
                              'a t -> edge -> f:('a option -> 'a) -> 'a t
                            val find : 'a t -> edge -> 'a option
                            val find_exn : 'a t -> edge -> 'a
                            val remove : 'a t -> edge -> 'a t
                            val mem : 'a t -> edge -> bool
                            val iter_keys : 'a t -> f:(edge -> unit) -> unit
                            val iter : 'a t -> f:('-> unit) -> unit
                            val iteri :
                              'a t -> f:(key:edge -> data:'-> unit) -> unit
                            val iter2 :
                              'a t ->
                              'b t ->
                              f:(key:edge ->
                                 data:[ `Both of 'a * 'b
                                      | `Left of 'a
                                      | `Right of 'b ] ->
                                 unit) ->
                              unit
                            val map : 'a t -> f:('-> 'b) -> 'b t
                            val mapi :
                              'a t -> f:(key:edge -> data:'-> 'b) -> 'b t
                            val fold :
                              'a t ->
                              init:'->
                              f:(key:edge -> data:'-> '-> 'b) -> 'b
                            val fold_right :
                              'a t ->
                              init:'->
                              f:(key:edge -> data:'-> '-> 'b) -> 'b
                            val fold2 :
                              'a t ->
                              'b t ->
                              init:'->
                              f:(key:edge ->
                                 data:[ `Both of 'a * 'b
                                      | `Left of 'a
                                      | `Right of 'b ] ->
                                 '-> 'c) ->
                              'c
                            val filter_keys :
                              'a t -> f:(edge -> bool) -> 'a t
                            val filter : 'a t -> f:('-> bool) -> 'a t
                            val filteri :
                              'a t -> f:(key:edge -> data:'-> bool) -> 'a t
                            val filter_map :
                              'a t -> f:('-> 'b option) -> 'b t
                            val filter_mapi :
                              'a t ->
                              f:(key:edge -> data:'-> 'b option) -> 'b t
                            val partition_mapi :
                              'a t ->
                              f:(key:edge ->
                                 data:'-> [ `Fst of '| `Snd of 'c ]) ->
                              'b t * 'c t
                            val partition_map :
                              'a t ->
                              f:('-> [ `Fst of '| `Snd of 'c ]) ->
                              'b t * 'c t
                            val partitioni_tf :
                              'a t ->
                              f:(key:edge -> data:'-> bool) -> 'a t * 'a t
                            val partition_tf :
                              'a t -> f:('-> bool) -> 'a t * 'a t
                            val compare_direct :
                              ('-> '-> int) -> 'a t -> 'a t -> int
                            val equal :
                              ('-> '-> bool) -> 'a t -> 'a t -> bool
                            val keys : 'a t -> edge list
                            val data : 'a t -> 'a list
                            val to_alist :
                              ?key_order:[ `Decreasing | `Increasing ] ->
                              'a t -> (edge * 'a) list
                            val validate :
                              name:(edge -> string) ->
                              'Base__.Validate.check ->
                              'a t Base__.Validate.check
                            val merge :
                              'a t ->
                              'b t ->
                              f:(key:edge ->
                                 [ `Both of 'a * 'b
                                 | `Left of 'a
                                 | `Right of 'b ] -> 'c option) ->
                              'c t
                            val symmetric_diff :
                              'a t ->
                              'a t ->
                              data_equal:('-> '-> bool) ->
                              (edge, 'a)
                              Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                              Base__.Sequence.t
                            val min_elt : 'a t -> (edge * 'a) option
                            val min_elt_exn : 'a t -> edge * 'a
                            val max_elt : 'a t -> (edge * 'a) option
                            val max_elt_exn : 'a t -> edge * 'a
                            val for_all : 'a t -> f:('-> bool) -> bool
                            val for_alli :
                              'a t -> f:(key:edge -> data:'-> bool) -> bool
                            val exists : 'a t -> f:('-> bool) -> bool
                            val existsi :
                              'a t -> f:(key:edge -> data:'-> bool) -> bool
                            val count : 'a t -> f:('-> bool) -> int
                            val counti :
                              'a t -> f:(key:edge -> data:'-> bool) -> int
                            val split :
                              'a t ->
                              edge -> 'a t * (edge * 'a) option * 'a t
                            val append :
                              lower_part:'a t ->
                              upper_part:'a t ->
                              [ `Ok of 'a t | `Overlapping_key_ranges ]
                            val subrange :
                              'a t ->
                              lower_bound:edge Base__.Maybe_bound.t ->
                              upper_bound:edge Base__.Maybe_bound.t -> 'a t
                            val fold_range_inclusive :
                              'a t ->
                              min:edge ->
                              max:edge ->
                              init:'->
                              f:(key:edge -> data:'-> '-> 'b) -> 'b
                            val range_to_alist :
                              'a t ->
                              min:edge -> max:edge -> (edge * 'a) list
                            val closest_key :
                              'a t ->
                              [ `Greater_or_equal_to
                              | `Greater_than
                              | `Less_or_equal_to
                              | `Less_than ] -> edge -> (edge * 'a) option
                            val nth : 'a t -> int -> (edge * 'a) option
                            val nth_exn : 'a t -> int -> edge * 'a
                            val rank : 'a t -> edge -> int option
                            val to_tree : 'a t -> 'a t
                            val to_sequence :
                              ?order:[ `Decreasing_key | `Increasing_key ] ->
                              ?keys_greater_or_equal_to:edge ->
                              ?keys_less_or_equal_to:edge ->
                              'a t -> (edge * 'a) Base__.Sequence.t
                            val obs :
                              edge Core_kernel__.Quickcheck.Observer.t ->
                              'Core_kernel__.Quickcheck.Observer.t ->
                              'v t Core_kernel__.Quickcheck.Observer.t
                            val shrinker :
                              edge Core_kernel__.Quickcheck.Shrinker.t ->
                              'Core_kernel__.Quickcheck.Shrinker.t ->
                              'v t Core_kernel__.Quickcheck.Shrinker.t
                            module Provide_of_sexp :
                              functor
                                (K : sig
                                       val t_of_sexp : Sexplib.Sexp.t -> edge
                                     end->
                                sig
                                  val t_of_sexp :
                                    (Sexplib.Sexp.t -> 'v_x__017_) ->
                                    Sexplib.Sexp.t -> 'v_x__017_ t
                                end
                            val t_of_sexp :
                              (Base__.Sexplib.Sexp.t -> 'a) ->
                              Base__.Sexplib.Sexp.t -> 'a t
                            val sexp_of_t :
                              ('-> Base__.Sexplib.Sexp.t) ->
                              'a t -> Base__.Sexplib.Sexp.t
                          end
                        type 'a t =
                            (edge, 'a, comparator_witness)
                            Core_kernel__.Core_map_intf.Map.t
                        val compare :
                          ('-> '-> Core_kernel__.Import.int) ->
                          'a t -> 'a t -> Core_kernel__.Import.int
                        val empty : 'a t
                        val singleton : edge -> '-> 'a t
                        val of_alist :
                          (edge * 'a) list ->
                          [ `Duplicate_key of edge | `Ok of 'a t ]
                        val of_alist_or_error :
                          (edge * 'a) list -> 'a t Base__.Or_error.t
                        val of_alist_exn : (edge * 'a) list -> 'a t
                        val of_alist_multi : (edge * 'a) list -> 'a list t
                        val of_alist_fold :
                          (edge * 'a) list ->
                          init:'-> f:('-> '-> 'b) -> 'b t
                        val of_alist_reduce :
                          (edge * 'a) list -> f:('-> '-> 'a) -> 'a t
                        val of_sorted_array :
                          (edge * 'a) array -> 'a t Base__.Or_error.t
                        val of_sorted_array_unchecked :
                          (edge * 'a) array -> 'a t
                        val of_increasing_iterator_unchecked :
                          len:int -> f:(int -> edge * 'a) -> 'a t
                        val of_iteri :
                          iteri:(f:(key:edge -> data:'-> unit) -> unit) ->
                          [ `Duplicate_key of edge | `Ok of 'v t ]
                        val of_tree : 'Tree.t -> 'a t
                        val of_hashtbl_exn :
                          (edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                        val gen :
                          edge Core_kernel__.Quickcheck.Generator.t ->
                          'Core_kernel__.Quickcheck.Generator.t ->
                          'a t Core_kernel__.Quickcheck.Generator.t
                        val invariants : 'a t -> bool
                        val is_empty : 'a t -> bool
                        val length : 'a t -> int
                        val add : 'a t -> key:edge -> data:'-> 'a t
                        val add_multi :
                          'a list t -> key:edge -> data:'-> 'a list t
                        val remove_multi : 'a list t -> edge -> 'a list t
                        val change :
                          'a t -> edge -> f:('a option -> 'a option) -> 'a t
                        val update :
                          'a t -> edge -> f:('a option -> 'a) -> 'a t
                        val find : 'a t -> edge -> 'a option
                        val find_exn : 'a t -> edge -> 'a
                        val remove : 'a t -> edge -> 'a t
                        val mem : 'a t -> edge -> bool
                        val iter_keys : 'a t -> f:(edge -> unit) -> unit
                        val iter : 'a t -> f:('-> unit) -> unit
                        val iteri :
                          'a t -> f:(key:edge -> data:'-> unit) -> unit
                        val iter2 :
                          'a t ->
                          'b t ->
                          f:(key:edge ->
                             data:[ `Both of 'a * 'b
                                  | `Left of 'a
                                  | `Right of 'b ] ->
                             unit) ->
                          unit
                        val map : 'a t -> f:('-> 'b) -> 'b t
                        val mapi :
                          'a t -> f:(key:edge -> data:'-> 'b) -> 'b t
                        val fold :
                          'a t ->
                          init:'->
                          f:(key:edge -> data:'-> '-> 'b) -> 'b
                        val fold_right :
                          'a t ->
                          init:'->
                          f:(key:edge -> data:'-> '-> 'b) -> 'b
                        val fold2 :
                          'a t ->
                          'b t ->
                          init:'->
                          f:(key:edge ->
                             data:[ `Both of 'a * 'b
                                  | `Left of 'a
                                  | `Right of 'b ] ->
                             '-> 'c) ->
                          'c
                        val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
                        val filter : 'a t -> f:('-> bool) -> 'a t
                        val filteri :
                          'a t -> f:(key:edge -> data:'-> bool) -> 'a t
                        val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                        val filter_mapi :
                          'a t ->
                          f:(key:edge -> data:'-> 'b option) -> 'b t
                        val partition_mapi :
                          'a t ->
                          f:(key:edge ->
                             data:'-> [ `Fst of '| `Snd of 'c ]) ->
                          'b t * 'c t
                        val partition_map :
                          'a t ->
                          f:('-> [ `Fst of '| `Snd of 'c ]) ->
                          'b t * 'c t
                        val partitioni_tf :
                          'a t ->
                          f:(key:edge -> data:'-> bool) -> 'a t * 'a t
                        val partition_tf :
                          'a t -> f:('-> bool) -> 'a t * 'a t
                        val compare_direct :
                          ('-> '-> int) -> 'a t -> 'a t -> int
                        val equal :
                          ('-> '-> bool) -> 'a t -> 'a t -> bool
                        val keys : 'a t -> edge list
                        val data : 'a t -> 'a list
                        val to_alist :
                          ?key_order:[ `Decreasing | `Increasing ] ->
                          'a t -> (edge * 'a) list
                        val validate :
                          name:(edge -> string) ->
                          'Base__.Validate.check ->
                          'a t Base__.Validate.check
                        val merge :
                          'a t ->
                          'b t ->
                          f:(key:edge ->
                             [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                             'c option) ->
                          'c t
                        val symmetric_diff :
                          'a t ->
                          'a t ->
                          data_equal:('-> '-> bool) ->
                          (edge, 'a)
                          Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                          Base__.Sequence.t
                        val min_elt : 'a t -> (edge * 'a) option
                        val min_elt_exn : 'a t -> edge * 'a
                        val max_elt : 'a t -> (edge * 'a) option
                        val max_elt_exn : 'a t -> edge * 'a
                        val for_all : 'a t -> f:('-> bool) -> bool
                        val for_alli :
                          'a t -> f:(key:edge -> data:'-> bool) -> bool
                        val exists : 'a t -> f:('-> bool) -> bool
                        val existsi :
                          'a t -> f:(key:edge -> data:'-> bool) -> bool
                        val count : 'a t -> f:('-> bool) -> int
                        val counti :
                          'a t -> f:(key:edge -> data:'-> bool) -> int
                        val split :
                          'a t -> edge -> 'a t * (edge * 'a) option * 'a t
                        val append :
                          lower_part:'a t ->
                          upper_part:'a t ->
                          [ `Ok of 'a t | `Overlapping_key_ranges ]
                        val subrange :
                          'a t ->
                          lower_bound:edge Base__.Maybe_bound.t ->
                          upper_bound:edge Base__.Maybe_bound.t -> 'a t
                        val fold_range_inclusive :
                          'a t ->
                          min:edge ->
                          max:edge ->
                          init:'->
                          f:(key:edge -> data:'-> '-> 'b) -> 'b
                        val range_to_alist :
                          'a t -> min:edge -> max:edge -> (edge * 'a) list
                        val closest_key :
                          'a t ->
                          [ `Greater_or_equal_to
                          | `Greater_than
                          | `Less_or_equal_to
                          | `Less_than ] -> edge -> (edge * 'a) option
                        val nth : 'a t -> int -> (edge * 'a) option
                        val nth_exn : 'a t -> int -> edge * 'a
                        val rank : 'a t -> edge -> int option
                        val to_tree : 'a t -> 'Tree.t
                        val to_sequence :
                          ?order:[ `Decreasing_key | `Increasing_key ] ->
                          ?keys_greater_or_equal_to:edge ->
                          ?keys_less_or_equal_to:edge ->
                          'a t -> (edge * 'a) Base__.Sequence.t
                        val obs :
                          edge Core_kernel__.Quickcheck.Observer.t ->
                          'Core_kernel__.Quickcheck.Observer.t ->
                          'v t Core_kernel__.Quickcheck.Observer.t
                        val shrinker :
                          edge Core_kernel__.Quickcheck.Shrinker.t ->
                          'Core_kernel__.Quickcheck.Shrinker.t ->
                          'v t Core_kernel__.Quickcheck.Shrinker.t
                        module Provide_of_sexp :
                          functor
                            (Key : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> edge
                                   end->
                            sig
                              val t_of_sexp :
                                (Sexplib.Sexp.t -> 'v_x__018_) ->
                                Sexplib.Sexp.t -> 'v_x__018_ t
                            end
                        module Provide_bin_io :
                          functor
                            (Key : sig
                                     val bin_t : edge Bin_prot.Type_class.t
                                     val bin_read_t :
                                       edge Bin_prot.Read.reader
                                     val __bin_read_t__ :
                                       (Core_kernel__.Import.int -> edge)
                                       Bin_prot.Read.reader
                                     val bin_reader_t :
                                       edge Bin_prot.Type_class.reader
                                     val bin_size_t :
                                       edge Bin_prot.Size.sizer
                                     val bin_write_t :
                                       edge Bin_prot.Write.writer
                                     val bin_writer_t :
                                       edge Bin_prot.Type_class.writer
                                     val bin_shape_t : Bin_prot.Shape.t
                                   end->
                            sig
                              val bin_shape_t :
                                Bin_prot.Shape.t -> Bin_prot.Shape.t
                              val bin_size_t :
                                ('a, 'a t) Bin_prot.Size.sizer1
                              val bin_write_t :
                                ('a, 'a t) Bin_prot.Write.writer1
                              val bin_read_t :
                                ('a, 'a t) Bin_prot.Read.reader1
                              val __bin_read_t__ :
                                ('a, int -> 'a t) Bin_prot.Read.reader1
                              val bin_writer_t :
                                ('a, 'a t) Bin_prot.Type_class.S1.writer
                              val bin_reader_t :
                                ('a, 'a t) Bin_prot.Type_class.S1.reader
                              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                            end
                        module Provide_hash :
                          functor
                            (Key : sig
                                     val hash_fold_t :
                                       Base__.Hash.state ->
                                       edge -> Base__.Hash.state
                                   end->
                            sig
                              val hash_fold_t :
                                (Ppx_hash_lib.Std.Hash.state ->
                                 '-> Ppx_hash_lib.Std.Hash.state) ->
                                Ppx_hash_lib.Std.Hash.state ->
                                'a t -> Ppx_hash_lib.Std.Hash.state
                            end
                        val t_of_sexp :
                          (Base__.Sexplib.Sexp.t -> 'a) ->
                          Base__.Sexplib.Sexp.t -> 'a t
                        val sexp_of_t :
                          ('-> Base__.Sexplib.Sexp.t) ->
                          'a t -> Base__.Sexplib.Sexp.t
                      end
                    module Set :
                      sig
                        module Elt :
                          sig
                            type t = edge
                            val t_of_sexp : Sexplib.Sexp.t -> t
                            val sexp_of_t : t -> Sexplib.Sexp.t
                            type comparator_witness =
                                Map.Key.comparator_witness
                            val comparator :
                              (t, comparator_witness)
                              Core_kernel__.Comparator.comparator
                          end
                        module Tree :
                          sig
                            type t =
                                (edge, comparator_witness)
                                Core_kernel__.Core_set_intf.Tree.t
                            val compare : t -> t -> Core_kernel__.Import.int
                            val length : t -> int
                            val is_empty : t -> bool
                            val iter : t -> f:(edge -> unit) -> unit
                            val fold :
                              t ->
                              init:'accum ->
                              f:('accum -> edge -> 'accum) -> 'accum
                            val fold_result :
                              t ->
                              init:'accum ->
                              f:('accum ->
                                 edge -> ('accum, 'e) Base__.Result.t) ->
                              ('accum, 'e) Base__.Result.t
                            val exists : t -> f:(edge -> bool) -> bool
                            val for_all : t -> f:(edge -> bool) -> bool
                            val count : t -> f:(edge -> bool) -> int
                            val sum :
                              (module Base__.Commutative_group.S with type t = 'sum) ->
                              t -> f:(edge -> 'sum) -> 'sum
                            val find : t -> f:(edge -> bool) -> edge option
                            val find_map :
                              t -> f:(edge -> 'a option) -> 'a option
                            val to_list : t -> edge list
                            val to_array : t -> edge array
                            val invariants : t -> bool
                            val mem : t -> edge -> bool
                            val add : t -> edge -> t
                            val remove : t -> edge -> t
                            val union : t -> t -> t
                            val inter : t -> t -> t
                            val diff : t -> t -> t
                            val symmetric_diff :
                              t ->
                              t ->
                              (edge, edge) Base__.Either.t Base__.Sequence.t
                            val compare_direct : t -> t -> int
                            val equal : t -> t -> bool
                            val is_subset : t -> of_:t -> bool
                            val subset : t -> t -> bool
                            val fold_until :
                              t ->
                              init:'->
                              f:('->
                                 edge ->
                                 ('b, 'stop)
                                 Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                              ('b, 'stop)
                              Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                            val fold_right :
                              t -> init:'-> f:(edge -> '-> 'b) -> 'b
                            val iter2 :
                              t ->
                              t ->
                              f:([ `Both of edge * edge
                                 | `Left of edge
                                 | `Right of edge ] -> unit) ->
                              unit
                            val filter : t -> f:(edge -> bool) -> t
                            val partition_tf : t -> f:(edge -> bool) -> t * t
                            val elements : t -> edge list
                            val min_elt : t -> edge option
                            val min_elt_exn : t -> edge
                            val max_elt : t -> edge option
                            val max_elt_exn : t -> edge
                            val choose : t -> edge option
                            val choose_exn : t -> edge
                            val split : t -> edge -> t * edge option * t
                            val group_by :
                              t -> equiv:(edge -> edge -> bool) -> t list
                            val find_exn : t -> f:(edge -> bool) -> edge
                            val find_index : t -> int -> edge option
                            val nth : t -> int -> edge option
                            val remove_index : t -> int -> t
                            val to_tree : t -> t
                            val to_sequence :
                              ?order:[ `Decreasing | `Increasing ] ->
                              ?greater_or_equal_to:edge ->
                              ?less_or_equal_to:edge ->
                              t -> edge Base__.Sequence.t
                            val merge_to_sequence :
                              ?order:[ `Decreasing | `Increasing ] ->
                              ?greater_or_equal_to:edge ->
                              ?less_or_equal_to:edge ->
                              t ->
                              t ->
                              (edge, edge)
                              Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                              Base__.Sequence.t
                            val to_map :
                              t ->
                              f:(edge -> 'data) ->
                              (edge, 'data, comparator_witness)
                              Core_kernel__.Core_set_intf.Map.t
                            val obs :
                              edge Core_kernel__.Quickcheck.Observer.t ->
                              t Core_kernel__.Quickcheck.Observer.t
                            val shrinker :
                              edge Core_kernel__.Quickcheck.Shrinker.t ->
                              t Core_kernel__.Quickcheck.Shrinker.t
                            val empty : t
                            val singleton : edge -> t
                            val union_list : t list -> t
                            val of_list : edge list -> t
                            val of_array : edge array -> t
                            val of_sorted_array :
                              edge array -> t Base__.Or_error.t
                            val of_sorted_array_unchecked : edge array -> t
                            val of_increasing_iterator_unchecked :
                              len:int -> f:(int -> edge) -> t
                            val stable_dedup_list : edge list -> edge list
                            val map :
                              ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                              f:('-> edge) -> t
                            val filter_map :
                              ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                              f:('-> edge option) -> t
                            val of_tree : t -> t
                            val of_hash_set :
                              edge Core_kernel__.Hash_set.t -> t
                            val of_hashtbl_keys :
                              (edge, 'a) Core_kernel__.Core_hashtbl.t -> t
                            val of_map_keys :
                              (edge, 'a, comparator_witness)
                              Core_kernel__.Core_set_intf.Map.t -> t
                            val gen :
                              edge Core_kernel__.Quickcheck.Generator.t ->
                              t Core_kernel__.Quickcheck.Generator.t
                            module Provide_of_sexp :
                              functor
                                (Elt : sig
                                         val t_of_sexp :
                                           Sexplib.Sexp.t -> edge
                                       end->
                                sig val t_of_sexp : Sexplib.Sexp.t -> t end
                            val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                            val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                          end
                        type t = (edge, comparator_witness) Base.Set.t
                        val compare : t -> t -> Core_kernel__.Import.int
                        val length : t -> int
                        val is_empty : t -> bool
                        val iter : t -> f:(edge -> unit) -> unit
                        val fold :
                          t ->
                          init:'accum ->
                          f:('accum -> edge -> 'accum) -> 'accum
                        val fold_result :
                          t ->
                          init:'accum ->
                          f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
                          ('accum, 'e) Base__.Result.t
                        val exists : t -> f:(edge -> bool) -> bool
                        val for_all : t -> f:(edge -> bool) -> bool
                        val count : t -> f:(edge -> bool) -> int
                        val sum :
                          (module Base__.Commutative_group.S with type t = 'sum) ->
                          t -> f:(edge -> 'sum) -> 'sum
                        val find : t -> f:(edge -> bool) -> edge option
                        val find_map :
                          t -> f:(edge -> 'a option) -> 'a option
                        val to_list : t -> edge list
                        val to_array : t -> edge array
                        val invariants : t -> bool
                        val mem : t -> edge -> bool
                        val add : t -> edge -> t
                        val remove : t -> edge -> t
                        val union : t -> t -> t
                        val inter : t -> t -> t
                        val diff : t -> t -> t
                        val symmetric_diff :
                          t ->
                          t -> (edge, edge) Base__.Either.t Base__.Sequence.t
                        val compare_direct : t -> t -> int
                        val equal : t -> t -> bool
                        val is_subset : t -> of_:t -> bool
                        val subset : t -> t -> bool
                        val fold_until :
                          t ->
                          init:'->
                          f:('->
                             edge ->
                             ('b, 'stop)
                             Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                          ('b, 'stop)
                          Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                        val fold_right :
                          t -> init:'-> f:(edge -> '-> 'b) -> 'b
                        val iter2 :
                          t ->
                          t ->
                          f:([ `Both of edge * edge
                             | `Left of edge
                             | `Right of edge ] -> unit) ->
                          unit
                        val filter : t -> f:(edge -> bool) -> t
                        val partition_tf : t -> f:(edge -> bool) -> t * t
                        val elements : t -> edge list
                        val min_elt : t -> edge option
                        val min_elt_exn : t -> edge
                        val max_elt : t -> edge option
                        val max_elt_exn : t -> edge
                        val choose : t -> edge option
                        val choose_exn : t -> edge
                        val split : t -> edge -> t * edge option * t
                        val group_by :
                          t -> equiv:(edge -> edge -> bool) -> t list
                        val find_exn : t -> f:(edge -> bool) -> edge
                        val find_index : t -> int -> edge option
                        val nth : t -> int -> edge option
                        val remove_index : t -> int -> t
                        val to_tree : t -> Tree.t
                        val to_sequence :
                          ?order:[ `Decreasing | `Increasing ] ->
                          ?greater_or_equal_to:edge ->
                          ?less_or_equal_to:edge ->
                          t -> edge Base__.Sequence.t
                        val merge_to_sequence :
                          ?order:[ `Decreasing | `Increasing ] ->
                          ?greater_or_equal_to:edge ->
                          ?less_or_equal_to:edge ->
                          t ->
                          t ->
                          (edge, edge)
                          Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                          Base__.Sequence.t
                        val to_map :
                          t ->
                          f:(edge -> 'data) ->
                          (edge, 'data, comparator_witness)
                          Core_kernel__.Core_set_intf.Map.t
                        val obs :
                          edge Core_kernel__.Quickcheck.Observer.t ->
                          t Core_kernel__.Quickcheck.Observer.t
                        val shrinker :
                          edge Core_kernel__.Quickcheck.Shrinker.t ->
                          t Core_kernel__.Quickcheck.Shrinker.t
                        val empty : t
                        val singleton : edge -> t
                        val union_list : t list -> t
                        val of_list : edge list -> t
                        val of_array : edge array -> t
                        val of_sorted_array :
                          edge array -> t Base__.Or_error.t
                        val of_sorted_array_unchecked : edge array -> t
                        val of_increasing_iterator_unchecked :
                          len:int -> f:(int -> edge) -> t
                        val stable_dedup_list : edge list -> edge list
                        val map : ('a, 'b) Base.Set.t -> f:('-> edge) -> t
                        val filter_map :
                          ('a, 'b) Base.Set.t -> f:('-> edge option) -> t
                        val of_tree : Tree.t -> t
                        val of_hash_set : edge Core_kernel__.Hash_set.t -> t
                        val of_hashtbl_keys :
                          (edge, 'a) Core_kernel__.Core_hashtbl.t -> t
                        val of_map_keys :
                          (edge, 'a, comparator_witness)
                          Core_kernel__.Core_set_intf.Map.t -> t
                        val gen :
                          edge Core_kernel__.Quickcheck.Generator.t ->
                          t Core_kernel__.Quickcheck.Generator.t
                        module Provide_of_sexp :
                          functor
                            (Elt : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> edge
                                   end->
                            sig val t_of_sexp : Sexplib.Sexp.t -> t end
                        module Provide_bin_io :
                          functor
                            (Elt : sig
                                     val bin_t : edge Bin_prot.Type_class.t
                                     val bin_read_t :
                                       edge Bin_prot.Read.reader
                                     val __bin_read_t__ :
                                       (Core_kernel__.Import.int -> edge)
                                       Bin_prot.Read.reader
                                     val bin_reader_t :
                                       edge Bin_prot.Type_class.reader
                                     val bin_size_t :
                                       edge Bin_prot.Size.sizer
                                     val bin_write_t :
                                       edge Bin_prot.Write.writer
                                     val bin_writer_t :
                                       edge Bin_prot.Type_class.writer
                                     val bin_shape_t : Bin_prot.Shape.t
                                   end->
                            sig
                              val bin_size_t : t Bin_prot.Size.sizer
                              val bin_write_t : t Bin_prot.Write.writer
                              val bin_read_t : t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                (int -> t) Bin_prot.Read.reader
                              val bin_shape_t : Bin_prot.Shape.t
                              val bin_writer_t : t Bin_prot.Type_class.writer
                              val bin_reader_t : t Bin_prot.Type_class.reader
                              val bin_t : t Bin_prot.Type_class.t
                            end
                        module Provide_hash :
                          functor
                            (Elt : sig
                                     val hash_fold_t :
                                       Base__.Hash.state ->
                                       edge -> Base__.Hash.state
                                   end->
                            sig
                              val hash_fold_t :
                                Ppx_hash_lib.Std.Hash.state ->
                                t -> Ppx_hash_lib.Std.Hash.state
                              val hash :
                                t -> Ppx_hash_lib.Std.Hash.hash_value
                            end
                        val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                        val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                      end
                    val hash : t -> Core_kernel__.Import.int
                    val compare : t -> t -> Core_kernel__.Import.int
                    val hashable :
                      t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
                    module Table :
                      sig
                        type key = t
                        type ('a, 'b) hashtbl = ('a, 'b) Node.Table.hashtbl
                        type 'b t = (key, 'b) hashtbl
                        val sexp_of_t :
                          ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                        type ('a, 'b) t_ = 'b t
                        type 'a key_ = key
                        val hashable :
                          key Core_kernel__.Core_hashtbl_intf.Hashable.t
                        val invariant :
                          'Base__.Invariant_intf.inv ->
                          'a t Base__.Invariant_intf.inv
                        val create :
                          (key, 'b, unit -> 'b t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist :
                          (key, 'b,
                           (key * 'b) list ->
                           [ `Duplicate_key of key | `Ok of 'b t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_report_all_dups :
                          (key, 'b,
                           (key * 'b) list ->
                           [ `Duplicate_keys of key list | `Ok of 'b t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_or_error :
                          (key, 'b,
                           (key * 'b) list -> 'b t Base__.Or_error.t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_exn :
                          (key, 'b, (key * 'b) list -> 'b t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_multi :
                          (key, 'b list, (key * 'b) list -> 'b list t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_mapped :
                          (key, 'b,
                           get_key:('-> key) ->
                           get_data:('-> 'b) ->
                           'r list ->
                           [ `Duplicate_keys of key list | `Ok of 'b t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_with_key :
                          (key, 'r,
                           get_key:('-> key) ->
                           'r list ->
                           [ `Duplicate_keys of key list | `Ok of 'r t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_with_key_or_error :
                          (key, 'r,
                           get_key:('-> key) ->
                           'r list -> 'r t Base__.Or_error.t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_with_key_exn :
                          (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val group :
                          (key, 'b,
                           get_key:('-> key) ->
                           get_data:('-> 'b) ->
                           combine:('-> '-> 'b) -> 'r list -> 'b t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                        val clear : 'a t -> unit
                        val copy : 'b t -> 'b t
                        val fold :
                          'b t ->
                          init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                        val iter_keys : 'a t -> f:(key -> unit) -> unit
                        val iter : 'b t -> f:('-> unit) -> unit
                        val iteri :
                          'b t -> f:(key:key -> data:'-> unit) -> unit
                        val iter_vals : 'b t -> f:('-> unit) -> unit
                        val existsi :
                          'b t -> f:(key:key -> data:'-> bool) -> bool
                        val exists : 'b t -> f:('-> bool) -> bool
                        val for_alli :
                          'b t -> f:(key:key -> data:'-> bool) -> bool
                        val for_all : 'b t -> f:('-> bool) -> bool
                        val counti :
                          'b t -> f:(key:key -> data:'-> bool) -> int
                        val count : 'b t -> f:('-> bool) -> int
                        val length : 'a t -> int
                        val is_empty : 'a t -> bool
                        val mem : 'a t -> key -> bool
                        val remove : 'a t -> key -> unit
                        val replace : 'b t -> key:key -> data:'-> unit
                        val set : 'b t -> key:key -> data:'-> unit
                        val add :
                          'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                        val add_or_error :
                          'b t ->
                          key:key -> data:'-> unit Base__.Or_error.t
                        val add_exn : 'b t -> key:key -> data:'-> unit
                        val change :
                          'b t -> key -> f:('b option -> 'b option) -> unit
                        val update :
                          'b t -> key -> f:('b option -> 'b) -> unit
                        val add_multi :
                          'b list t -> key:key -> data:'-> unit
                        val remove_multi : 'a list t -> key -> unit
                        val map : 'b t -> f:('-> 'c) -> 'c t
                        val mapi :
                          'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                        val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                        val filter_mapi :
                          'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                        val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                        val filter : 'b t -> f:('-> bool) -> 'b t
                        val filteri :
                          'b t -> f:(key:key -> data:'-> bool) -> 'b t
                        val partition_map :
                          'b t ->
                          f:('-> [ `Fst of '| `Snd of 'd ]) ->
                          'c t * 'd t
                        val partition_mapi :
                          'b t ->
                          f:(key:key ->
                             data:'-> [ `Fst of '| `Snd of 'd ]) ->
                          'c t * 'd t
                        val partition_tf :
                          'b t -> f:('-> bool) -> 'b t * 'b t
                        val partitioni_tf :
                          'b t ->
                          f:(key:key -> data:'-> bool) -> 'b t * 'b t
                        val find_or_add :
                          'b t -> key -> default:(unit -> 'b) -> 'b
                        val find : 'b t -> key -> 'b option
                        val find_exn : 'b t -> key -> 'b
                        val find_and_call :
                          'b t ->
                          key ->
                          if_found:('-> 'c) ->
                          if_not_found:(key -> 'c) -> 'c
                        val find_and_remove : 'b t -> key -> 'b option
                        val merge :
                          'a t ->
                          'b t ->
                          f:(key:key ->
                             [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                             'c option) ->
                          'c t
                        type 'a merge_into_action =
                          'G.Edge.Table.merge_into_action =
                            Remove
                          | Set_to of 'a
                        val merge_into :
                          src:'a t ->
                          dst:'b t ->
                          f:(key:key ->
                             '-> 'b option -> 'b merge_into_action) ->
                          unit
                        val keys : 'a t -> key list
                        val data : 'b t -> 'b list
                        val filter_keys_inplace :
                          'a t -> f:(key -> bool) -> unit
                        val filter_inplace : 'b t -> f:('-> bool) -> unit
                        val filteri_inplace :
                          'b t -> f:(key:key -> data:'-> bool) -> unit
                        val map_inplace : 'b t -> f:('-> 'b) -> unit
                        val mapi_inplace :
                          'b t -> f:(key:key -> data:'-> 'b) -> unit
                        val filter_map_inplace :
                          'b t -> f:('-> 'b option) -> unit
                        val filter_mapi_inplace :
                          'b t -> f:(key:key -> data:'-> 'b option) -> unit
                        val replace_all : 'b t -> f:('-> 'b) -> unit
                        val replace_alli :
                          'b t -> f:(key:key -> data:'-> 'b) -> unit
                        val filter_replace_all :
                          'b t -> f:('-> 'b option) -> unit
                        val filter_replace_alli :
                          'b t -> f:(key:key -> data:'-> 'b option) -> unit
                        val equal :
                          'b t -> 'b t -> ('-> '-> bool) -> bool
                        val similar :
                          'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                        val to_alist : 'b t -> (key * 'b) list
                        val validate :
                          name:(key -> string) ->
                          'Base__.Validate.check ->
                          'b t Base__.Validate.check
                        val incr :
                          ?by:int ->
                          ?remove_if_zero:bool -> int t -> key -> unit
                        val decr :
                          ?by:int ->
                          ?remove_if_zero:bool -> int t -> key -> unit
                        module Provide_of_sexp :
                          functor
                            (Key : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> key
                                   end->
                            sig
                              val t_of_sexp :
                                (Sexplib.Sexp.t -> 'v_x__001_) ->
                                Sexplib.Sexp.t -> 'v_x__001_ t
                            end
                        module Provide_bin_io :
                          functor
                            (Key : sig
                                     val bin_t : key Bin_prot.Type_class.t
                                     val bin_read_t :
                                       key Bin_prot.Read.reader
                                     val __bin_read_t__ :
                                       (Core_kernel__.Import.int -> key)
                                       Bin_prot.Read.reader
                                     val bin_reader_t :
                                       key Bin_prot.Type_class.reader
                                     val bin_size_t : key Bin_prot.Size.sizer
                                     val bin_write_t :
                                       key Bin_prot.Write.writer
                                     val bin_writer_t :
                                       key Bin_prot.Type_class.writer
                                     val bin_shape_t : Bin_prot.Shape.t
                                   end->
                            sig
                              val bin_t :
                                'Bin_prot.Type_class.t ->
                                'a t Bin_prot.Type_class.t
                              val bin_read_t :
                                'Bin_prot.Read.reader ->
                                'a t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                'Bin_prot.Read.reader ->
                                (Core_kernel__.Import.int -> 'a t)
                                Bin_prot.Read.reader
                              val bin_reader_t :
                                'Bin_prot.Type_class.reader ->
                                'a t Bin_prot.Type_class.reader
                              val bin_size_t :
                                'Bin_prot.Size.sizer ->
                                'a t Bin_prot.Size.sizer
                              val bin_write_t :
                                'Bin_prot.Write.writer ->
                                'a t Bin_prot.Write.writer
                              val bin_writer_t :
                                'Bin_prot.Type_class.writer ->
                                'a t Bin_prot.Type_class.writer
                              val bin_shape_t :
                                Bin_prot.Shape.t -> Bin_prot.Shape.t
                            end
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__002_) ->
                          Sexplib.Sexp.t -> 'v_x__002_ t
                      end
                    module Hash_set :
                      sig
                        type elt = t
                        type t = elt Core_kernel__.Hash_set.t
                        val sexp_of_t : t -> Sexplib.Sexp.t
                        type 'a t_ = t
                        type 'a elt_ = elt
                        val create :
                          ('a, unit -> t)
                          Core_kernel__.Hash_set_intf.create_options_without_hashable
                        val of_list :
                          ('a, elt list -> t)
                          Core_kernel__.Hash_set_intf.create_options_without_hashable
                        module Provide_of_sexp :
                          functor
                            (X : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> elt
                                 end->
                            sig val t_of_sexp : Sexplib.Sexp.t -> t end
                        module Provide_bin_io :
                          functor
                            (X : sig
                                   val bin_t : elt Bin_prot.Type_class.t
                                   val bin_read_t : elt Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> elt)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     elt Bin_prot.Type_class.reader
                                   val bin_size_t : elt Bin_prot.Size.sizer
                                   val bin_write_t :
                                     elt Bin_prot.Write.writer
                                   val bin_writer_t :
                                     elt Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                            sig
                              val bin_t : t Bin_prot.Type_class.t
                              val bin_read_t : t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                (Core_kernel__.Import.int -> t)
                                Bin_prot.Read.reader
                              val bin_reader_t : t Bin_prot.Type_class.reader
                              val bin_size_t : t Bin_prot.Size.sizer
                              val bin_write_t : t Bin_prot.Write.writer
                              val bin_writer_t : t Bin_prot.Type_class.writer
                              val bin_shape_t : Bin_prot.Shape.t
                            end
                        val t_of_sexp : Sexplib.Sexp.t -> t
                      end
                    module Hash_queue :
                      sig
                        module Key :
                          sig
                            type t = edge
                            val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                            val compare : t -> t -> int
                            val hash : t -> int
                          end
                        type 'a t = 'G.Edge.Hash_queue.t
                        val sexp_of_t :
                          ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                        val length : 'a t -> int
                        val is_empty : 'a t -> bool
                        val iter : 'a t -> f:('-> unit) -> unit
                        val fold :
                          'a t ->
                          init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                        val fold_result :
                          'a t ->
                          init:'accum ->
                          f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                          ('accum, 'e) Base__.Result.t
                        val fold_until :
                          'a t ->
                          init:'accum ->
                          f:('accum ->
                             '->
                             ('accum, 'stop)
                             Base.Container_intf.Continue_or_stop.t) ->
                          ('accum, 'stop)
                          Base.Container_intf.Finished_or_stopped_early.t
                        val exists : 'a t -> f:('-> bool) -> bool
                        val for_all : 'a t -> f:('-> bool) -> bool
                        val count : 'a t -> f:('-> bool) -> int
                        val sum :
                          (module Base__.Commutative_group.S with type t = 'sum) ->
                          'a t -> f:('-> 'sum) -> 'sum
                        val find : 'a t -> f:('-> bool) -> 'a option
                        val find_map :
                          'a t -> f:('-> 'b option) -> 'b option
                        val to_list : 'a t -> 'a list
                        val to_array : 'a t -> 'a array
                        val min_elt :
                          'a t -> cmp:('-> '-> int) -> 'a option
                        val max_elt :
                          'a t -> cmp:('-> '-> int) -> 'a option
                        val invariant : 'a t -> Core_kernel__.Import.unit
                        val create :
                          ?growth_allowed:Core_kernel__.Import.bool ->
                          ?size:Core_kernel__.Import.int ->
                          Core_kernel__.Import.unit -> 'a t
                        val clear : 'a t -> Core_kernel__.Import.unit
                        val mem : 'a t -> edge -> Core_kernel__.Import.bool
                        val lookup :
                          'a t -> edge -> 'Core_kernel__.Import.option
                        val lookup_exn : 'a t -> edge -> 'a
                        val enqueue :
                          'a t ->
                          edge -> '-> [ `Key_already_present | `Ok ]
                        val enqueue_exn :
                          'a t -> edge -> '-> Core_kernel__.Import.unit
                        val lookup_and_move_to_back :
                          'a t -> edge -> 'Core_kernel__.Import.option
                        val lookup_and_move_to_back_exn : 'a t -> edge -> 'a
                        val first : 'a t -> 'Core_kernel__.Import.option
                        val first_with_key :
                          'a t -> (edge * 'a) Core_kernel__.Import.option
                        val keys : 'a t -> edge Core_kernel__.Import.list
                        val dequeue : 'a t -> 'Core_kernel__.Import.option
                        val dequeue_exn : 'a t -> 'a
                        val dequeue_with_key :
                          'a t -> (edge * 'a) Core_kernel__.Import.option
                        val dequeue_with_key_exn : 'a t -> edge * 'a
                        val dequeue_all :
                          'a t ->
                          f:('-> Core_kernel__.Import.unit) ->
                          Core_kernel__.Import.unit
                        val remove : 'a t -> edge -> [ `No_such_key | `Ok ]
                        val remove_exn :
                          'a t -> edge -> Core_kernel__.Import.unit
                        val replace :
                          'a t -> edge -> '-> [ `No_such_key | `Ok ]
                        val replace_exn :
                          'a t -> edge -> '-> Core_kernel__.Import.unit
                        val iteri :
                          'a t ->
                          f:(key:edge -> data:'-> Core_kernel__.Import.unit) ->
                          Core_kernel__.Import.unit
                        val foldi :
                          'a t ->
                          init:'->
                          f:('-> key:edge -> data:'-> 'b) -> 'b
                      end
                  end
                val empty : t
                val nodes : t -> node Regular.Std.seq
                val edges : t -> edge Regular.Std.seq
                val is_directed : bool
                val number_of_edges : t -> int
                val number_of_nodes : t -> int
                val ( >= ) : t -> t -> bool
                val ( <= ) : t -> t -> bool
                val ( = ) : t -> t -> bool
                val ( > ) : t -> t -> bool
                val ( < ) : t -> t -> bool
                val ( <> ) : t -> t -> bool
                val equal : t -> t -> bool
                val min : t -> t -> t
                val max : t -> t -> t
                val ascending : t -> t -> int
                val descending : t -> t -> int
                val between : t -> low:t -> high:t -> bool
                val clamp_exn : t -> min:t -> max:t -> t
                val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
                type comparator_witness
                val comparator :
                  (t, comparator_witness) Base__.Comparator.comparator
                val validate_lbound :
                  min:t Base__.Maybe_bound.t -> t Base__.Validate.check
                val validate_ubound :
                  max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                val validate_bound :
                  min:t Base__.Maybe_bound.t ->
                  max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                module Replace_polymorphic_compare :
                  sig
                    val ( >= ) : t -> t -> bool
                    val ( <= ) : t -> t -> bool
                    val ( = ) : t -> t -> bool
                    val ( > ) : t -> t -> bool
                    val ( < ) : t -> t -> bool
                    val ( <> ) : t -> t -> bool
                    val equal : t -> t -> bool
                    val compare : t -> t -> int
                    val min : t -> t -> t
                    val max : t -> t -> t
                  end
                module Map :
                  sig
                    module Key :
                      sig
                        type t = Edge.graph
                        val t_of_sexp : Sexplib.Sexp.t -> t
                        val sexp_of_t : t -> Sexplib.Sexp.t
                        type comparator_witness = comparator_witness
                        val comparator :
                          (t, comparator_witness)
                          Core_kernel__.Comparator.comparator
                      end
                    module Tree :
                      sig
                        type 'a t =
                            (Key.t, 'a, comparator_witness)
                            Core_kernel__.Core_map_intf.Tree.t
                        val empty : 'a t
                        val singleton : Key.t -> '-> 'a t
                        val of_alist :
                          (Key.t * 'a) list ->
                          [ `Duplicate_key of Key.t | `Ok of 'a t ]
                        val of_alist_or_error :
                          (Key.t * 'a) list -> 'a t Base__.Or_error.t
                        val of_alist_exn : (Key.t * 'a) list -> 'a t
                        val of_alist_multi : (Key.t * 'a) list -> 'a list t
                        val of_alist_fold :
                          (Key.t * 'a) list ->
                          init:'-> f:('-> '-> 'b) -> 'b t
                        val of_alist_reduce :
                          (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                        val of_sorted_array :
                          (Key.t * 'a) array -> 'a t Base__.Or_error.t
                        val of_sorted_array_unchecked :
                          (Key.t * 'a) array -> 'a t
                        val of_increasing_iterator_unchecked :
                          len:int -> f:(int -> Key.t * 'a) -> 'a t
                        val of_iteri :
                          iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                          [ `Duplicate_key of Key.t | `Ok of 'v t ]
                        val of_tree : 'a t -> 'a t
                        val of_hashtbl_exn :
                          (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                        val gen :
                          Key.t Core_kernel__.Quickcheck.Generator.t ->
                          'Core_kernel__.Quickcheck.Generator.t ->
                          'a t Core_kernel__.Quickcheck.Generator.t
                        val invariants : 'a t -> bool
                        val is_empty : 'a t -> bool
                        val length : 'a t -> int
                        val add : 'a t -> key:Key.t -> data:'-> 'a t
                        val add_multi :
                          'a list t -> key:Key.t -> data:'-> 'a list t
                        val remove_multi : 'a list t -> Key.t -> 'a list t
                        val change :
                          'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                        val update :
                          'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                        val find : 'a t -> Key.t -> 'a option
                        val find_exn : 'a t -> Key.t -> 'a
                        val remove : 'a t -> Key.t -> 'a t
                        val mem : 'a t -> Key.t -> bool
                        val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                        val iter : 'a t -> f:('-> unit) -> unit
                        val iteri :
                          'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                        val iter2 :
                          'a t ->
                          'b t ->
                          f:(key:Key.t ->
                             data:[ `Both of 'a * 'b
                                  | `Left of 'a
                                  | `Right of 'b ] ->
                             unit) ->
                          unit
                        val map : 'a t -> f:('-> 'b) -> 'b t
                        val mapi :
                          'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                        val fold :
                          'a t ->
                          init:'->
                          f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                        val fold_right :
                          'a t ->
                          init:'->
                          f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                        val fold2 :
                          'a t ->
                          'b t ->
                          init:'->
                          f:(key:Key.t ->
                             data:[ `Both of 'a * 'b
                                  | `Left of 'a
                                  | `Right of 'b ] ->
                             '-> 'c) ->
                          'c
                        val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                        val filter : 'a t -> f:('-> bool) -> 'a t
                        val filteri :
                          'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                        val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                        val filter_mapi :
                          'a t ->
                          f:(key:Key.t -> data:'-> 'b option) -> 'b t
                        val partition_mapi :
                          'a t ->
                          f:(key:Key.t ->
                             data:'-> [ `Fst of '| `Snd of 'c ]) ->
                          'b t * 'c t
                        val partition_map :
                          'a t ->
                          f:('-> [ `Fst of '| `Snd of 'c ]) ->
                          'b t * 'c t
                        val partitioni_tf :
                          'a t ->
                          f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                        val partition_tf :
                          'a t -> f:('-> bool) -> 'a t * 'a t
                        val compare_direct :
                          ('-> '-> int) -> 'a t -> 'a t -> int
                        val equal :
                          ('-> '-> bool) -> 'a t -> 'a t -> bool
                        val keys : 'a t -> Key.t list
                        val data : 'a t -> 'a list
                        val to_alist :
                          ?key_order:[ `Decreasing | `Increasing ] ->
                          'a t -> (Key.t * 'a) list
                        val validate :
                          name:(Key.t -> string) ->
                          'Base__.Validate.check ->
                          'a t Base__.Validate.check
                        val merge :
                          'a t ->
                          'b t ->
                          f:(key:Key.t ->
                             [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                             'c option) ->
                          'c t
                        val symmetric_diff :
                          'a t ->
                          'a t ->
                          data_equal:('-> '-> bool) ->
                          (Key.t, 'a)
                          Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                          Base__.Sequence.t
                        val min_elt : 'a t -> (Key.t * 'a) option
                        val min_elt_exn : 'a t -> Key.t * 'a
                        val max_elt : 'a t -> (Key.t * 'a) option
                        val max_elt_exn : 'a t -> Key.t * 'a
                        val for_all : 'a t -> f:('-> bool) -> bool
                        val for_alli :
                          'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                        val exists : 'a t -> f:('-> bool) -> bool
                        val existsi :
                          'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                        val count : 'a t -> f:('-> bool) -> int
                        val counti :
                          'a t -> f:(key:Key.t -> data:'-> bool) -> int
                        val split :
                          'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                        val append :
                          lower_part:'a t ->
                          upper_part:'a t ->
                          [ `Ok of 'a t | `Overlapping_key_ranges ]
                        val subrange :
                          'a t ->
                          lower_bound:Key.t Base__.Maybe_bound.t ->
                          upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                        val fold_range_inclusive :
                          'a t ->
                          min:Key.t ->
                          max:Key.t ->
                          init:'->
                          f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                        val range_to_alist :
                          'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                        val closest_key :
                          'a t ->
                          [ `Greater_or_equal_to
                          | `Greater_than
                          | `Less_or_equal_to
                          | `Less_than ] -> Key.t -> (Key.t * 'a) option
                        val nth : 'a t -> int -> (Key.t * 'a) option
                        val nth_exn : 'a t -> int -> Key.t * 'a
                        val rank : 'a t -> Key.t -> int option
                        val to_tree : 'a t -> 'a t
                        val to_sequence :
                          ?order:[ `Decreasing_key | `Increasing_key ] ->
                          ?keys_greater_or_equal_to:Key.t ->
                          ?keys_less_or_equal_to:Key.t ->
                          'a t -> (Key.t * 'a) Base__.Sequence.t
                        val obs :
                          Key.t Core_kernel__.Quickcheck.Observer.t ->
                          'Core_kernel__.Quickcheck.Observer.t ->
                          'v t Core_kernel__.Quickcheck.Observer.t
                        val shrinker :
                          Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                          'Core_kernel__.Quickcheck.Shrinker.t ->
                          'v t Core_kernel__.Quickcheck.Shrinker.t
                        module Provide_of_sexp :
                          functor
                            (K : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> Key.t
                                 end->
                            sig
                              val t_of_sexp :
                                (Sexplib.Sexp.t -> 'v_x__017_) ->
                                Sexplib.Sexp.t -> 'v_x__017_ t
                            end
                        val t_of_sexp :
                          (Base__.Sexplib.Sexp.t -> 'a) ->
                          Base__.Sexplib.Sexp.t -> 'a t
                        val sexp_of_t :
                          ('-> Base__.Sexplib.Sexp.t) ->
                          'a t -> Base__.Sexplib.Sexp.t
                      end
                    type 'a t =
                        (Key.t, 'a, comparator_witness)
                        Core_kernel__.Core_map_intf.Map.t
                    val compare :
                      ('-> '-> Core_kernel__.Import.int) ->
                      'a t -> 'a t -> Core_kernel__.Import.int
                    val empty : 'a t
                    val singleton : Key.t -> '-> 'a t
                    val of_alist :
                      (Key.t * 'a) list ->
                      [ `Duplicate_key of Key.t | `Ok of 'a t ]
                    val of_alist_or_error :
                      (Key.t * 'a) list -> 'a t Base__.Or_error.t
                    val of_alist_exn : (Key.t * 'a) list -> 'a t
                    val of_alist_multi : (Key.t * 'a) list -> 'a list t
                    val of_alist_fold :
                      (Key.t * 'a) list ->
                      init:'-> f:('-> '-> 'b) -> 'b t
                    val of_alist_reduce :
                      (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                    val of_sorted_array :
                      (Key.t * 'a) array -> 'a t Base__.Or_error.t
                    val of_sorted_array_unchecked :
                      (Key.t * 'a) array -> 'a t
                    val of_increasing_iterator_unchecked :
                      len:int -> f:(int -> Key.t * 'a) -> 'a t
                    val of_iteri :
                      iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                      [ `Duplicate_key of Key.t | `Ok of 'v t ]
                    val of_tree : 'Tree.t -> 'a t
                    val of_hashtbl_exn :
                      (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                    val gen :
                      Key.t Core_kernel__.Quickcheck.Generator.t ->
                      'Core_kernel__.Quickcheck.Generator.t ->
                      'a t Core_kernel__.Quickcheck.Generator.t
                    val invariants : 'a t -> bool
                    val is_empty : 'a t -> bool
                    val length : 'a t -> int
                    val add : 'a t -> key:Key.t -> data:'-> 'a t
                    val add_multi :
                      'a list t -> key:Key.t -> data:'-> 'a list t
                    val remove_multi : 'a list t -> Key.t -> 'a list t
                    val change :
                      'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                    val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                    val find : 'a t -> Key.t -> 'a option
                    val find_exn : 'a t -> Key.t -> 'a
                    val remove : 'a t -> Key.t -> 'a t
                    val mem : 'a t -> Key.t -> bool
                    val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                    val iter : 'a t -> f:('-> unit) -> unit
                    val iteri :
                      'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                    val iter2 :
                      'a t ->
                      'b t ->
                      f:(key:Key.t ->
                         data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                         unit) ->
                      unit
                    val map : 'a t -> f:('-> 'b) -> 'b t
                    val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                    val fold :
                      'a t ->
                      init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                    val fold_right :
                      'a t ->
                      init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                    val fold2 :
                      'a t ->
                      'b t ->
                      init:'->
                      f:(key:Key.t ->
                         data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                         '-> 'c) ->
                      'c
                    val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                    val filter : 'a t -> f:('-> bool) -> 'a t
                    val filteri :
                      'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                    val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                    val filter_mapi :
                      'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                    val partition_mapi :
                      'a t ->
                      f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                      'b t * 'c t
                    val partition_map :
                      'a t ->
                      f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                    val partitioni_tf :
                      'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                    val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                    val compare_direct :
                      ('-> '-> int) -> 'a t -> 'a t -> int
                    val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                    val keys : 'a t -> Key.t list
                    val data : 'a t -> 'a list
                    val to_alist :
                      ?key_order:[ `Decreasing | `Increasing ] ->
                      'a t -> (Key.t * 'a) list
                    val validate :
                      name:(Key.t -> string) ->
                      'Base__.Validate.check -> 'a t Base__.Validate.check
                    val merge :
                      'a t ->
                      'b t ->
                      f:(key:Key.t ->
                         [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                         'c option) ->
                      'c t
                    val symmetric_diff :
                      'a t ->
                      'a t ->
                      data_equal:('-> '-> bool) ->
                      (Key.t, 'a)
                      Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                      Base__.Sequence.t
                    val min_elt : 'a t -> (Key.t * 'a) option
                    val min_elt_exn : 'a t -> Key.t * 'a
                    val max_elt : 'a t -> (Key.t * 'a) option
                    val max_elt_exn : 'a t -> Key.t * 'a
                    val for_all : 'a t -> f:('-> bool) -> bool
                    val for_alli :
                      'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                    val exists : 'a t -> f:('-> bool) -> bool
                    val existsi :
                      'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                    val count : 'a t -> f:('-> bool) -> int
                    val counti :
                      'a t -> f:(key:Key.t -> data:'-> bool) -> int
                    val split :
                      'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                    val append :
                      lower_part:'a t ->
                      upper_part:'a t ->
                      [ `Ok of 'a t | `Overlapping_key_ranges ]
                    val subrange :
                      'a t ->
                      lower_bound:Key.t Base__.Maybe_bound.t ->
                      upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                    val fold_range_inclusive :
                      'a t ->
                      min:Key.t ->
                      max:Key.t ->
                      init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                    val range_to_alist :
                      'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                    val closest_key :
                      'a t ->
                      [ `Greater_or_equal_to
                      | `Greater_than
                      | `Less_or_equal_to
                      | `Less_than ] -> Key.t -> (Key.t * 'a) option
                    val nth : 'a t -> int -> (Key.t * 'a) option
                    val nth_exn : 'a t -> int -> Key.t * 'a
                    val rank : 'a t -> Key.t -> int option
                    val to_tree : 'a t -> 'Tree.t
                    val to_sequence :
                      ?order:[ `Decreasing_key | `Increasing_key ] ->
                      ?keys_greater_or_equal_to:Key.t ->
                      ?keys_less_or_equal_to:Key.t ->
                      'a t -> (Key.t * 'a) Base__.Sequence.t
                    val obs :
                      Key.t Core_kernel__.Quickcheck.Observer.t ->
                      'Core_kernel__.Quickcheck.Observer.t ->
                      'v t Core_kernel__.Quickcheck.Observer.t
                    val shrinker :
                      Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                      'Core_kernel__.Quickcheck.Shrinker.t ->
                      'v t Core_kernel__.Quickcheck.Shrinker.t
                    module Provide_of_sexp :
                      functor
                        (Key : sig
                                 val t_of_sexp : Sexplib.Sexp.t -> Key.t
                               end->
                        sig
                          val t_of_sexp :
                            (Sexplib.Sexp.t -> 'v_x__018_) ->
                            Sexplib.Sexp.t -> 'v_x__018_ t
                        end
                    module Provide_bin_io :
                      functor
                        (Key : sig
                                 val bin_t : Key.t Bin_prot.Type_class.t
                                 val bin_read_t : Key.t Bin_prot.Read.reader
                                 val __bin_read_t__ :
                                   (Core_kernel__.Import.int -> Key.t)
                                   Bin_prot.Read.reader
                                 val bin_reader_t :
                                   Key.t Bin_prot.Type_class.reader
                                 val bin_size_t : Key.t Bin_prot.Size.sizer
                                 val bin_write_t :
                                   Key.t Bin_prot.Write.writer
                                 val bin_writer_t :
                                   Key.t Bin_prot.Type_class.writer
                                 val bin_shape_t : Bin_prot.Shape.t
                               end->
                        sig
                          val bin_shape_t :
                            Bin_prot.Shape.t -> Bin_prot.Shape.t
                          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                          val __bin_read_t__ :
                            ('a, int -> 'a t) Bin_prot.Read.reader1
                          val bin_writer_t :
                            ('a, 'a t) Bin_prot.Type_class.S1.writer
                          val bin_reader_t :
                            ('a, 'a t) Bin_prot.Type_class.S1.reader
                          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                        end
                    module Provide_hash :
                      functor
                        (Key : sig
                                 val hash_fold_t :
                                   Base__.Hash.state ->
                                   Key.t -> Base__.Hash.state
                               end->
                        sig
                          val hash_fold_t :
                            (Ppx_hash_lib.Std.Hash.state ->
                             '-> Ppx_hash_lib.Std.Hash.state) ->
                            Ppx_hash_lib.Std.Hash.state ->
                            'a t -> Ppx_hash_lib.Std.Hash.state
                        end
                    val t_of_sexp :
                      (Base__.Sexplib.Sexp.t -> 'a) ->
                      Base__.Sexplib.Sexp.t -> 'a t
                    val sexp_of_t :
                      ('-> Base__.Sexplib.Sexp.t) ->
                      'a t -> Base__.Sexplib.Sexp.t
                  end
                module Set :
                  sig
                    module Elt :
                      sig
                        type t = Edge.graph
                        val t_of_sexp : Sexplib.Sexp.t -> t
                        val sexp_of_t : t -> Sexplib.Sexp.t
                        type comparator_witness = Map.Key.comparator_witness
                        val comparator :
                          (t, comparator_witness)
                          Core_kernel__.Comparator.comparator
                      end
                    module Tree :
                      sig
                        type t =
                            (Elt.t, comparator_witness)
                            Core_kernel__.Core_set_intf.Tree.t
                        val compare : t -> t -> Core_kernel__.Import.int
                        val length : t -> int
                        val is_empty : t -> bool
                        val iter : t -> f:(Elt.t -> unit) -> unit
                        val fold :
                          t ->
                          init:'accum ->
                          f:('accum -> Elt.t -> 'accum) -> 'accum
                        val fold_result :
                          t ->
                          init:'accum ->
                          f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                          ('accum, 'e) Base__.Result.t
                        val exists : t -> f:(Elt.t -> bool) -> bool
                        val for_all : t -> f:(Elt.t -> bool) -> bool
                        val count : t -> f:(Elt.t -> bool) -> int
                        val sum :
                          (module Base__.Commutative_group.S with type t = 'sum) ->
                          t -> f:(Elt.t -> 'sum) -> 'sum
                        val find : t -> f:(Elt.t -> bool) -> Elt.t option
                        val find_map :
                          t -> f:(Elt.t -> 'a option) -> 'a option
                        val to_list : t -> Elt.t list
                        val to_array : t -> Elt.t array
                        val invariants : t -> bool
                        val mem : t -> Elt.t -> bool
                        val add : t -> Elt.t -> t
                        val remove : t -> Elt.t -> t
                        val union : t -> t -> t
                        val inter : t -> t -> t
                        val diff : t -> t -> t
                        val symmetric_diff :
                          t ->
                          t ->
                          (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                        val compare_direct : t -> t -> int
                        val equal : t -> t -> bool
                        val is_subset : t -> of_:t -> bool
                        val subset : t -> t -> bool
                        val fold_until :
                          t ->
                          init:'->
                          f:('->
                             Elt.t ->
                             ('b, 'stop)
                             Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                          ('b, 'stop)
                          Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                        val fold_right :
                          t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                        val iter2 :
                          t ->
                          t ->
                          f:([ `Both of Elt.t * Elt.t
                             | `Left of Elt.t
                             | `Right of Elt.t ] -> unit) ->
                          unit
                        val filter : t -> f:(Elt.t -> bool) -> t
                        val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                        val elements : t -> Elt.t list
                        val min_elt : t -> Elt.t option
                        val min_elt_exn : t -> Elt.t
                        val max_elt : t -> Elt.t option
                        val max_elt_exn : t -> Elt.t
                        val choose : t -> Elt.t option
                        val choose_exn : t -> Elt.t
                        val split : t -> Elt.t -> t * Elt.t option * t
                        val group_by :
                          t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                        val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                        val find_index : t -> int -> Elt.t option
                        val nth : t -> int -> Elt.t option
                        val remove_index : t -> int -> t
                        val to_tree : t -> t
                        val to_sequence :
                          ?order:[ `Decreasing | `Increasing ] ->
                          ?greater_or_equal_to:Elt.t ->
                          ?less_or_equal_to:Elt.t ->
                          t -> Elt.t Base__.Sequence.t
                        val merge_to_sequence :
                          ?order:[ `Decreasing | `Increasing ] ->
                          ?greater_or_equal_to:Elt.t ->
                          ?less_or_equal_to:Elt.t ->
                          t ->
                          t ->
                          (Elt.t, Elt.t)
                          Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                          Base__.Sequence.t
                        val to_map :
                          t ->
                          f:(Elt.t -> 'data) ->
                          (Elt.t, 'data, comparator_witness)
                          Core_kernel__.Core_set_intf.Map.t
                        val obs :
                          Elt.t Core_kernel__.Quickcheck.Observer.t ->
                          t Core_kernel__.Quickcheck.Observer.t
                        val shrinker :
                          Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                          t Core_kernel__.Quickcheck.Shrinker.t
                        val empty : t
                        val singleton : Elt.t -> t
                        val union_list : t list -> t
                        val of_list : Elt.t list -> t
                        val of_array : Elt.t array -> t
                        val of_sorted_array :
                          Elt.t array -> t Base__.Or_error.t
                        val of_sorted_array_unchecked : Elt.t array -> t
                        val of_increasing_iterator_unchecked :
                          len:int -> f:(int -> Elt.t) -> t
                        val stable_dedup_list : Elt.t list -> Elt.t list
                        val map :
                          ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                          f:('-> Elt.t) -> t
                        val filter_map :
                          ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                          f:('-> Elt.t option) -> t
                        val of_tree : t -> t
                        val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                        val of_hashtbl_keys :
                          (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                        val of_map_keys :
                          (Elt.t, 'a, comparator_witness)
                          Core_kernel__.Core_set_intf.Map.t -> t
                        val gen :
                          Elt.t Core_kernel__.Quickcheck.Generator.t ->
                          t Core_kernel__.Quickcheck.Generator.t
                        module Provide_of_sexp :
                          functor
                            (Elt : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> Elt.t
                                   end->
                            sig val t_of_sexp : Sexplib.Sexp.t -> t end
                        val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                        val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                      end
                    type t = (Elt.t, comparator_witness) Base.Set.t
                    val compare : t -> t -> Core_kernel__.Import.int
                    val length : t -> int
                    val is_empty : t -> bool
                    val iter : t -> f:(Elt.t -> unit) -> unit
                    val fold :
                      t ->
                      init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                    val fold_result :
                      t ->
                      init:'accum ->
                      f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                      ('accum, 'e) Base__.Result.t
                    val exists : t -> f:(Elt.t -> bool) -> bool
                    val for_all : t -> f:(Elt.t -> bool) -> bool
                    val count : t -> f:(Elt.t -> bool) -> int
                    val sum :
                      (module Base__.Commutative_group.S with type t = 'sum) ->
                      t -> f:(Elt.t -> 'sum) -> 'sum
                    val find : t -> f:(Elt.t -> bool) -> Elt.t option
                    val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                    val to_list : t -> Elt.t list
                    val to_array : t -> Elt.t array
                    val invariants : t -> bool
                    val mem : t -> Elt.t -> bool
                    val add : t -> Elt.t -> t
                    val remove : t -> Elt.t -> t
                    val union : t -> t -> t
                    val inter : t -> t -> t
                    val diff : t -> t -> t
                    val symmetric_diff :
                      t ->
                      t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                    val compare_direct : t -> t -> int
                    val equal : t -> t -> bool
                    val is_subset : t -> of_:t -> bool
                    val subset : t -> t -> bool
                    val fold_until :
                      t ->
                      init:'->
                      f:('->
                         Elt.t ->
                         ('b, 'stop)
                         Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                      ('b, 'stop)
                      Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                    val fold_right :
                      t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                    val iter2 :
                      t ->
                      t ->
                      f:([ `Both of Elt.t * Elt.t
                         | `Left of Elt.t
                         | `Right of Elt.t ] -> unit) ->
                      unit
                    val filter : t -> f:(Elt.t -> bool) -> t
                    val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                    val elements : t -> Elt.t list
                    val min_elt : t -> Elt.t option
                    val min_elt_exn : t -> Elt.t
                    val max_elt : t -> Elt.t option
                    val max_elt_exn : t -> Elt.t
                    val choose : t -> Elt.t option
                    val choose_exn : t -> Elt.t
                    val split : t -> Elt.t -> t * Elt.t option * t
                    val group_by :
                      t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                    val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                    val find_index : t -> int -> Elt.t option
                    val nth : t -> int -> Elt.t option
                    val remove_index : t -> int -> t
                    val to_tree : t -> Tree.t
                    val to_sequence :
                      ?order:[ `Decreasing | `Increasing ] ->
                      ?greater_or_equal_to:Elt.t ->
                      ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                    val merge_to_sequence :
                      ?order:[ `Decreasing | `Increasing ] ->
                      ?greater_or_equal_to:Elt.t ->
                      ?less_or_equal_to:Elt.t ->
                      t ->
                      t ->
                      (Elt.t, Elt.t)
                      Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                      Base__.Sequence.t
                    val to_map :
                      t ->
                      f:(Elt.t -> 'data) ->
                      (Elt.t, 'data, comparator_witness)
                      Core_kernel__.Core_set_intf.Map.t
                    val obs :
                      Elt.t Core_kernel__.Quickcheck.Observer.t ->
                      t Core_kernel__.Quickcheck.Observer.t
                    val shrinker :
                      Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                      t Core_kernel__.Quickcheck.Shrinker.t
                    val empty : t
                    val singleton : Elt.t -> t
                    val union_list : t list -> t
                    val of_list : Elt.t list -> t
                    val of_array : Elt.t array -> t
                    val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                    val of_sorted_array_unchecked : Elt.t array -> t
                    val of_increasing_iterator_unchecked :
                      len:int -> f:(int -> Elt.t) -> t
                    val stable_dedup_list : Elt.t list -> Elt.t list
                    val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
                    val filter_map :
                      ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
                    val of_tree : Tree.t -> t
                    val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                    val of_hashtbl_keys :
                      (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                    val of_map_keys :
                      (Elt.t, 'a, comparator_witness)
                      Core_kernel__.Core_set_intf.Map.t -> t
                    val gen :
                      Elt.t Core_kernel__.Quickcheck.Generator.t ->
                      t Core_kernel__.Quickcheck.Generator.t
                    module Provide_of_sexp :
                      functor
                        (Elt : sig
                                 val t_of_sexp : Sexplib.Sexp.t -> Elt.t
                               end->
                        sig val t_of_sexp : Sexplib.Sexp.t -> t end
                    module Provide_bin_io :
                      functor
                        (Elt : sig
                                 val bin_t : Elt.t Bin_prot.Type_class.t
                                 val bin_read_t : Elt.t Bin_prot.Read.reader
                                 val __bin_read_t__ :
                                   (Core_kernel__.Import.int -> Elt.t)
                                   Bin_prot.Read.reader
                                 val bin_reader_t :
                                   Elt.t Bin_prot.Type_class.reader
                                 val bin_size_t : Elt.t Bin_prot.Size.sizer
                                 val bin_write_t :
                                   Elt.t Bin_prot.Write.writer
                                 val bin_writer_t :
                                   Elt.t Bin_prot.Type_class.writer
                                 val bin_shape_t : Bin_prot.Shape.t
                               end->
                        sig
                          val bin_size_t : t Bin_prot.Size.sizer
                          val bin_write_t : t Bin_prot.Write.writer
                          val bin_read_t : t Bin_prot.Read.reader
                          val __bin_read_t__ :
                            (int -> t) Bin_prot.Read.reader
                          val bin_shape_t : Bin_prot.Shape.t
                          val bin_writer_t : t Bin_prot.Type_class.writer
                          val bin_reader_t : t Bin_prot.Type_class.reader
                          val bin_t : t Bin_prot.Type_class.t
                        end
                    module Provide_hash :
                      functor
                        (Elt : sig
                                 val hash_fold_t :
                                   Base__.Hash.state ->
                                   Elt.t -> Base__.Hash.state
                               end->
                        sig
                          val hash_fold_t :
                            Ppx_hash_lib.Std.Hash.state ->
                            t -> Ppx_hash_lib.Std.Hash.state
                          val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                        end
                    val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                    val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  end
                val hash : t -> Core_kernel__.Import.int
                val compare : t -> t -> Core_kernel__.Import.int
                val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
                module Table :
                  sig
                    type key = t
                    type ('a, 'b) hashtbl = ('a, 'b) Edge.Table.hashtbl
                    type 'b t = (key, 'b) hashtbl
                    val sexp_of_t :
                      ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                    type ('a, 'b) t_ = 'b t
                    type 'a key_ = key
                    val hashable :
                      key Core_kernel__.Core_hashtbl_intf.Hashable.t
                    val invariant :
                      'Base__.Invariant_intf.inv ->
                      'a t Base__.Invariant_intf.inv
                    val create :
                      (key, 'b, unit -> 'b t)
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val of_alist :
                      (key, 'b,
                       (key * 'b) list ->
                       [ `Duplicate_key of key | `Ok of 'b t ])
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val of_alist_report_all_dups :
                      (key, 'b,
                       (key * 'b) list ->
                       [ `Duplicate_keys of key list | `Ok of 'b t ])
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val of_alist_or_error :
                      (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val of_alist_exn :
                      (key, 'b, (key * 'b) list -> 'b t)
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val of_alist_multi :
                      (key, 'b list, (key * 'b) list -> 'b list t)
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val create_mapped :
                      (key, 'b,
                       get_key:('-> key) ->
                       get_data:('-> 'b) ->
                       'r list ->
                       [ `Duplicate_keys of key list | `Ok of 'b t ])
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val create_with_key :
                      (key, 'r,
                       get_key:('-> key) ->
                       'r list ->
                       [ `Duplicate_keys of key list | `Ok of 'r t ])
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val create_with_key_or_error :
                      (key, 'r,
                       get_key:('-> key) ->
                       'r list -> 'r t Base__.Or_error.t)
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val create_with_key_exn :
                      (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val group :
                      (key, 'b,
                       get_key:('-> key) ->
                       get_data:('-> 'b) ->
                       combine:('-> '-> 'b) -> 'r list -> 'b t)
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                    val clear : 'a t -> unit
                    val copy : 'b t -> 'b t
                    val fold :
                      'b t ->
                      init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                    val iter_keys : 'a t -> f:(key -> unit) -> unit
                    val iter : 'b t -> f:('-> unit) -> unit
                    val iteri :
                      'b t -> f:(key:key -> data:'-> unit) -> unit
                    val iter_vals : 'b t -> f:('-> unit) -> unit
                    val existsi :
                      'b t -> f:(key:key -> data:'-> bool) -> bool
                    val exists : 'b t -> f:('-> bool) -> bool
                    val for_alli :
                      'b t -> f:(key:key -> data:'-> bool) -> bool
                    val for_all : 'b t -> f:('-> bool) -> bool
                    val counti :
                      'b t -> f:(key:key -> data:'-> bool) -> int
                    val count : 'b t -> f:('-> bool) -> int
                    val length : 'a t -> int
                    val is_empty : 'a t -> bool
                    val mem : 'a t -> key -> bool
                    val remove : 'a t -> key -> unit
                    val replace : 'b t -> key:key -> data:'-> unit
                    val set : 'b t -> key:key -> data:'-> unit
                    val add :
                      'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                    val add_or_error :
                      'b t -> key:key -> data:'-> unit Base__.Or_error.t
                    val add_exn : 'b t -> key:key -> data:'-> unit
                    val change :
                      'b t -> key -> f:('b option -> 'b option) -> unit
                    val update : 'b t -> key -> f:('b option -> 'b) -> unit
                    val add_multi : 'b list t -> key:key -> data:'-> unit
                    val remove_multi : 'a list t -> key -> unit
                    val map : 'b t -> f:('-> 'c) -> 'c t
                    val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                    val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                    val filter_mapi :
                      'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                    val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                    val filter : 'b t -> f:('-> bool) -> 'b t
                    val filteri :
                      'b t -> f:(key:key -> data:'-> bool) -> 'b t
                    val partition_map :
                      'b t ->
                      f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                    val partition_mapi :
                      'b t ->
                      f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                      'c t * 'd t
                    val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
                    val partitioni_tf :
                      'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                    val find_or_add :
                      'b t -> key -> default:(unit -> 'b) -> 'b
                    val find : 'b t -> key -> 'b option
                    val find_exn : 'b t -> key -> 'b
                    val find_and_call :
                      'b t ->
                      key ->
                      if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                    val find_and_remove : 'b t -> key -> 'b option
                    val merge :
                      'a t ->
                      'b t ->
                      f:(key:key ->
                         [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                         'c option) ->
                      'c t
                    type 'a merge_into_action = Remove | Set_to of 'a
                    val merge_into :
                      src:'a t ->
                      dst:'b t ->
                      f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                      unit
                    val keys : 'a t -> key list
                    val data : 'b t -> 'b list
                    val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
                    val filter_inplace : 'b t -> f:('-> bool) -> unit
                    val filteri_inplace :
                      'b t -> f:(key:key -> data:'-> bool) -> unit
                    val map_inplace : 'b t -> f:('-> 'b) -> unit
                    val mapi_inplace :
                      'b t -> f:(key:key -> data:'-> 'b) -> unit
                    val filter_map_inplace :
                      'b t -> f:('-> 'b option) -> unit
                    val filter_mapi_inplace :
                      'b t -> f:(key:key -> data:'-> 'b option) -> unit
                    val replace_all : 'b t -> f:('-> 'b) -> unit
                    val replace_alli :
                      'b t -> f:(key:key -> data:'-> 'b) -> unit
                    val filter_replace_all :
                      'b t -> f:('-> 'b option) -> unit
                    val filter_replace_alli :
                      'b t -> f:(key:key -> data:'-> 'b option) -> unit
                    val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                    val similar :
                      'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                    val to_alist : 'b t -> (key * 'b) list
                    val validate :
                      name:(key -> string) ->
                      'Base__.Validate.check -> 'b t Base__.Validate.check
                    val incr :
                      ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                    val decr :
                      ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                    module Provide_of_sexp :
                      functor
                        (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                        sig
                          val t_of_sexp :
                            (Sexplib.Sexp.t -> 'v_x__001_) ->
                            Sexplib.Sexp.t -> 'v_x__001_ t
                        end
                    module Provide_bin_io :
                      functor
                        (Key : sig
                                 val bin_t : key Bin_prot.Type_class.t
                                 val bin_read_t : key Bin_prot.Read.reader
                                 val __bin_read_t__ :
                                   (Core_kernel__.Import.int -> key)
                                   Bin_prot.Read.reader
                                 val bin_reader_t :
                                   key Bin_prot.Type_class.reader
                                 val bin_size_t : key Bin_prot.Size.sizer
                                 val bin_write_t : key Bin_prot.Write.writer
                                 val bin_writer_t :
                                   key Bin_prot.Type_class.writer
                                 val bin_shape_t : Bin_prot.Shape.t
                               end->
                        sig
                          val bin_t :
                            'Bin_prot.Type_class.t ->
                            'a t Bin_prot.Type_class.t
                          val bin_read_t :
                            'Bin_prot.Read.reader ->
                            'a t Bin_prot.Read.reader
                          val __bin_read_t__ :
                            'Bin_prot.Read.reader ->
                            (Core_kernel__.Import.int -> 'a t)
                            Bin_prot.Read.reader
                          val bin_reader_t :
                            'Bin_prot.Type_class.reader ->
                            'a t Bin_prot.Type_class.reader
                          val bin_size_t :
                            'Bin_prot.Size.sizer ->
                            'a t Bin_prot.Size.sizer
                          val bin_write_t :
                            'Bin_prot.Write.writer ->
                            'a t Bin_prot.Write.writer
                          val bin_writer_t :
                            'Bin_prot.Type_class.writer ->
                            'a t Bin_prot.Type_class.writer
                          val bin_shape_t :
                            Bin_prot.Shape.t -> Bin_prot.Shape.t
                        end
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__002_) ->
                      Sexplib.Sexp.t -> 'v_x__002_ t
                  end
                module Hash_set :
                  sig
                    type elt = t
                    type t = elt Core_kernel__.Hash_set.t
                    val sexp_of_t : t -> Sexplib.Sexp.t
                    type 'a t_ = t
                    type 'a elt_ = elt
                    val create :
                      ('a, unit -> t)
                      Core_kernel__.Hash_set_intf.create_options_without_hashable
                    val of_list :
                      ('a, elt list -> t)
                      Core_kernel__.Hash_set_intf.create_options_without_hashable
                    module Provide_of_sexp :
                      functor
                        (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                        sig val t_of_sexp : Sexplib.Sexp.t -> t end
                    module Provide_bin_io :
                      functor
                        (X : sig
                               val bin_t : elt Bin_prot.Type_class.t
                               val bin_read_t : elt Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> elt)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 elt Bin_prot.Type_class.reader
                               val bin_size_t : elt Bin_prot.Size.sizer
                               val bin_write_t : elt Bin_prot.Write.writer
                               val bin_writer_t :
                                 elt Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                        sig
                          val bin_t : t Bin_prot.Type_class.t
                          val bin_read_t : t Bin_prot.Read.reader
                          val __bin_read_t__ :
                            (Core_kernel__.Import.int -> t)
                            Bin_prot.Read.reader
                          val bin_reader_t : t Bin_prot.Type_class.reader
                          val bin_size_t : t Bin_prot.Size.sizer
                          val bin_write_t : t Bin_prot.Write.writer
                          val bin_writer_t : t Bin_prot.Type_class.writer
                          val bin_shape_t : Bin_prot.Shape.t
                        end
                    val t_of_sexp : Sexplib.Sexp.t -> t
                  end
                module Hash_queue :
                  sig
                    module Key :
                      sig
                        type t = Hash_set.elt
                        val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                        val compare : t -> t -> int
                        val hash : t -> int
                      end
                    type 'a t
                    val sexp_of_t :
                      ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                    val length : 'a t -> int
                    val is_empty : 'a t -> bool
                    val iter : 'a t -> f:('-> unit) -> unit
                    val fold :
                      'a t ->
                      init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                    val fold_result :
                      'a t ->
                      init:'accum ->
                      f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                      ('accum, 'e) Base__.Result.t
                    val fold_until :
                      'a t ->
                      init:'accum ->
                      f:('accum ->
                         '->
                         ('accum, 'stop)
                         Base.Container_intf.Continue_or_stop.t) ->
                      ('accum, 'stop)
                      Base.Container_intf.Finished_or_stopped_early.t
                    val exists : 'a t -> f:('-> bool) -> bool
                    val for_all : 'a t -> f:('-> bool) -> bool
                    val count : 'a t -> f:('-> bool) -> int
                    val sum :
                      (module Base__.Commutative_group.S with type t = 'sum) ->
                      'a t -> f:('-> 'sum) -> 'sum
                    val find : 'a t -> f:('-> bool) -> 'a option
                    val find_map : 'a t -> f:('-> 'b option) -> 'b option
                    val to_list : 'a t -> 'a list
                    val to_array : 'a t -> 'a array
                    val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
                    val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
                    val invariant : 'a t -> Core_kernel__.Import.unit
                    val create :
                      ?growth_allowed:Core_kernel__.Import.bool ->
                      ?size:Core_kernel__.Import.int ->
                      Core_kernel__.Import.unit -> 'a t
                    val clear : 'a t -> Core_kernel__.Import.unit
                    val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
                    val lookup :
                      'a t -> Key.t -> 'Core_kernel__.Import.option
                    val lookup_exn : 'a t -> Key.t -> 'a
                    val enqueue :
                      'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
                    val enqueue_exn :
                      'a t -> Key.t -> '-> Core_kernel__.Import.unit
                    val lookup_and_move_to_back :
                      'a t -> Key.t -> 'Core_kernel__.Import.option
                    val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
                    val first : 'a t -> 'Core_kernel__.Import.option
                    val first_with_key :
                      'a t -> (Key.t * 'a) Core_kernel__.Import.option
                    val keys : 'a t -> Key.t Core_kernel__.Import.list
                    val dequeue : 'a t -> 'Core_kernel__.Import.option
                    val dequeue_exn : 'a t -> 'a
                    val dequeue_with_key :
                      'a t -> (Key.t * 'a) Core_kernel__.Import.option
                    val dequeue_with_key_exn : 'a t -> Key.t * 'a
                    val dequeue_all :
                      'a t ->
                      f:('-> Core_kernel__.Import.unit) ->
                      Core_kernel__.Import.unit
                    val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
                    val remove_exn :
                      'a t -> Key.t -> Core_kernel__.Import.unit
                    val replace :
                      'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
                    val replace_exn :
                      'a t -> Key.t -> '-> Core_kernel__.Import.unit
                    val iteri :
                      'a t ->
                      f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                      Core_kernel__.Import.unit
                    val foldi :
                      'a t ->
                      init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
                  end
                val to_string : t -> string
                val str : unit -> t -> string
                val pps : unit -> t -> string
                val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
                val pp_seq :
                  Format.formatter -> t Core_kernel.Std.Sequence.t -> unit
                val pp : Base__.Import.Caml.Format.formatter -> t -> unit
              end
          module Mapper :
            functor
              (G : Graph) (N : sig
                                 type s = G.node
                                 type t
                                 val forward : s -> t
                                 val backward : t -> s
                               end) (E : sig
                                           type s = G.edge
                                           type t
                                           val forward : s -> t
                                           val backward : t -> s
                                         end) (NL : sig
                                                      type s = G.Node.label
                                                      type t
                                                      val forward : s -> t
                                                      val backward : t -> s
                                                    end) (EL : sig
                                                                 type s =
                                                                    G.Edge.label
                                                                 type t
                                                                 val forward :
                                                                   s -> t
                                                                 val backward :
                                                                   t -> s
                                                               end->
              sig
                type t = G.t
                type node = N.t
                type edge = E.t
                module Node :
                  sig
                    type t = node
                    type graph = G.t
                    type label = NL.t
                    type edge = E.t
                    val create : label -> t
                    val label : t -> label
                    val mem : t -> graph -> bool
                    val succs : t -> graph -> t Regular.Std.seq
                    val preds : t -> graph -> t Regular.Std.seq
                    val inputs : t -> graph -> edge Regular.Std.seq
                    val outputs : t -> graph -> edge Regular.Std.seq
                    val degree : ?dir:[ `In | `Out ] -> t -> graph -> int
                    val insert : t -> graph -> graph
                    val update : t -> label -> graph -> graph
                    val remove : t -> graph -> graph
                    val has_edge : t -> t -> graph -> bool
                    val edge : t -> t -> graph -> edge option
                    val ( >= ) : t -> t -> bool
                    val ( <= ) : t -> t -> bool
                    val ( = ) : t -> t -> bool
                    val ( > ) : t -> t -> bool
                    val ( < ) : t -> t -> bool
                    val ( <> ) : t -> t -> bool
                    val equal : t -> t -> bool
                    val min : t -> t -> t
                    val max : t -> t -> t
                    val ascending : t -> t -> int
                    val descending : t -> t -> int
                    val between : t -> low:t -> high:t -> bool
                    val clamp_exn : t -> min:t -> max:t -> t
                    val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
                    type comparator_witness
                    val comparator :
                      (t, comparator_witness) Base__.Comparator.comparator
                    val validate_lbound :
                      min:t Base__.Maybe_bound.t -> t Base__.Validate.check
                    val validate_ubound :
                      max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                    val validate_bound :
                      min:t Base__.Maybe_bound.t ->
                      max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                    module Replace_polymorphic_compare :
                      sig
                        val ( >= ) : t -> t -> bool
                        val ( <= ) : t -> t -> bool
                        val ( = ) : t -> t -> bool
                        val ( > ) : t -> t -> bool
                        val ( < ) : t -> t -> bool
                        val ( <> ) : t -> t -> bool
                        val equal : t -> t -> bool
                        val compare : t -> t -> int
                        val min : t -> t -> t
                        val max : t -> t -> t
                      end
                    module Map :
                      sig
                        module Key :
                          sig
                            type t = node
                            val t_of_sexp : Sexplib.Sexp.t -> t
                            val sexp_of_t : t -> Sexplib.Sexp.t
                            type comparator_witness = comparator_witness
                            val comparator :
                              (t, comparator_witness)
                              Core_kernel__.Comparator.comparator
                          end
                        module Tree :
                          sig
                            type 'a t =
                                (node, 'a, comparator_witness)
                                Core_kernel__.Core_map_intf.Tree.t
                            val empty : 'a t
                            val singleton : node -> '-> 'a t
                            val of_alist :
                              (node * 'a) list ->
                              [ `Duplicate_key of node | `Ok of 'a t ]
                            val of_alist_or_error :
                              (node * 'a) list -> 'a t Base__.Or_error.t
                            val of_alist_exn : (node * 'a) list -> 'a t
                            val of_alist_multi :
                              (node * 'a) list -> 'a list t
                            val of_alist_fold :
                              (node * 'a) list ->
                              init:'-> f:('-> '-> 'b) -> 'b t
                            val of_alist_reduce :
                              (node * 'a) list -> f:('-> '-> 'a) -> 'a t
                            val of_sorted_array :
                              (node * 'a) array -> 'a t Base__.Or_error.t
                            val of_sorted_array_unchecked :
                              (node * 'a) array -> 'a t
                            val of_increasing_iterator_unchecked :
                              len:int -> f:(int -> node * 'a) -> 'a t
                            val of_iteri :
                              iteri:(f:(key:node -> data:'-> unit) -> unit) ->
                              [ `Duplicate_key of node | `Ok of 'v t ]
                            val of_tree : 'a t -> 'a t
                            val of_hashtbl_exn :
                              (node, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                            val gen :
                              node Core_kernel__.Quickcheck.Generator.t ->
                              'Core_kernel__.Quickcheck.Generator.t ->
                              'a t Core_kernel__.Quickcheck.Generator.t
                            val invariants : 'a t -> bool
                            val is_empty : 'a t -> bool
                            val length : 'a t -> int
                            val add : 'a t -> key:node -> data:'-> 'a t
                            val add_multi :
                              'a list t -> key:node -> data:'-> 'a list t
                            val remove_multi : 'a list t -> node -> 'a list t
                            val change :
                              'a t ->
                              node -> f:('a option -> 'a option) -> 'a t
                            val update :
                              'a t -> node -> f:('a option -> 'a) -> 'a t
                            val find : 'a t -> node -> 'a option
                            val find_exn : 'a t -> node -> 'a
                            val remove : 'a t -> node -> 'a t
                            val mem : 'a t -> node -> bool
                            val iter_keys : 'a t -> f:(node -> unit) -> unit
                            val iter : 'a t -> f:('-> unit) -> unit
                            val iteri :
                              'a t -> f:(key:node -> data:'-> unit) -> unit
                            val iter2 :
                              'a t ->
                              'b t ->
                              f:(key:node ->
                                 data:[ `Both of 'a * 'b
                                      | `Left of 'a
                                      | `Right of 'b ] ->
                                 unit) ->
                              unit
                            val map : 'a t -> f:('-> 'b) -> 'b t
                            val mapi :
                              'a t -> f:(key:node -> data:'-> 'b) -> 'b t
                            val fold :
                              'a t ->
                              init:'->
                              f:(key:node -> data:'-> '-> 'b) -> 'b
                            val fold_right :
                              'a t ->
                              init:'->
                              f:(key:node -> data:'-> '-> 'b) -> 'b
                            val fold2 :
                              'a t ->
                              'b t ->
                              init:'->
                              f:(key:node ->
                                 data:[ `Both of 'a * 'b
                                      | `Left of 'a
                                      | `Right of 'b ] ->
                                 '-> 'c) ->
                              'c
                            val filter_keys :
                              'a t -> f:(node -> bool) -> 'a t
                            val filter : 'a t -> f:('-> bool) -> 'a t
                            val filteri :
                              'a t -> f:(key:node -> data:'-> bool) -> 'a t
                            val filter_map :
                              'a t -> f:('-> 'b option) -> 'b t
                            val filter_mapi :
                              'a t ->
                              f:(key:node -> data:'-> 'b option) -> 'b t
                            val partition_mapi :
                              'a t ->
                              f:(key:node ->
                                 data:'-> [ `Fst of '| `Snd of 'c ]) ->
                              'b t * 'c t
                            val partition_map :
                              'a t ->
                              f:('-> [ `Fst of '| `Snd of 'c ]) ->
                              'b t * 'c t
                            val partitioni_tf :
                              'a t ->
                              f:(key:node -> data:'-> bool) -> 'a t * 'a t
                            val partition_tf :
                              'a t -> f:('-> bool) -> 'a t * 'a t
                            val compare_direct :
                              ('-> '-> int) -> 'a t -> 'a t -> int
                            val equal :
                              ('-> '-> bool) -> 'a t -> 'a t -> bool
                            val keys : 'a t -> node list
                            val data : 'a t -> 'a list
                            val to_alist :
                              ?key_order:[ `Decreasing | `Increasing ] ->
                              'a t -> (node * 'a) list
                            val validate :
                              name:(node -> string) ->
                              'Base__.Validate.check ->
                              'a t Base__.Validate.check
                            val merge :
                              'a t ->
                              'b t ->
                              f:(key:node ->
                                 [ `Both of 'a * 'b
                                 | `Left of 'a
                                 | `Right of 'b ] -> 'c option) ->
                              'c t
                            val symmetric_diff :
                              'a t ->
                              'a t ->
                              data_equal:('-> '-> bool) ->
                              (node, 'a)
                              Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                              Base__.Sequence.t
                            val min_elt : 'a t -> (node * 'a) option
                            val min_elt_exn : 'a t -> node * 'a
                            val max_elt : 'a t -> (node * 'a) option
                            val max_elt_exn : 'a t -> node * 'a
                            val for_all : 'a t -> f:('-> bool) -> bool
                            val for_alli :
                              'a t -> f:(key:node -> data:'-> bool) -> bool
                            val exists : 'a t -> f:('-> bool) -> bool
                            val existsi :
                              'a t -> f:(key:node -> data:'-> bool) -> bool
                            val count : 'a t -> f:('-> bool) -> int
                            val counti :
                              'a t -> f:(key:node -> data:'-> bool) -> int
                            val split :
                              'a t ->
                              node -> 'a t * (node * 'a) option * 'a t
                            val append :
                              lower_part:'a t ->
                              upper_part:'a t ->
                              [ `Ok of 'a t | `Overlapping_key_ranges ]
                            val subrange :
                              'a t ->
                              lower_bound:node Base__.Maybe_bound.t ->
                              upper_bound:node Base__.Maybe_bound.t -> 'a t
                            val fold_range_inclusive :
                              'a t ->
                              min:node ->
                              max:node ->
                              init:'->
                              f:(key:node -> data:'-> '-> 'b) -> 'b
                            val range_to_alist :
                              'a t ->
                              min:node -> max:node -> (node * 'a) list
                            val closest_key :
                              'a t ->
                              [ `Greater_or_equal_to
                              | `Greater_than
                              | `Less_or_equal_to
                              | `Less_than ] -> node -> (node * 'a) option
                            val nth : 'a t -> int -> (node * 'a) option
                            val nth_exn : 'a t -> int -> node * 'a
                            val rank : 'a t -> node -> int option
                            val to_tree : 'a t -> 'a t
                            val to_sequence :
                              ?order:[ `Decreasing_key | `Increasing_key ] ->
                              ?keys_greater_or_equal_to:node ->
                              ?keys_less_or_equal_to:node ->
                              'a t -> (node * 'a) Base__.Sequence.t
                            val obs :
                              node Core_kernel__.Quickcheck.Observer.t ->
                              'Core_kernel__.Quickcheck.Observer.t ->
                              'v t Core_kernel__.Quickcheck.Observer.t
                            val shrinker :
                              node Core_kernel__.Quickcheck.Shrinker.t ->
                              'Core_kernel__.Quickcheck.Shrinker.t ->
                              'v t Core_kernel__.Quickcheck.Shrinker.t
                            module Provide_of_sexp :
                              functor
                                (K : sig
                                       val t_of_sexp : Sexplib.Sexp.t -> node
                                     end->
                                sig
                                  val t_of_sexp :
                                    (Sexplib.Sexp.t -> 'v_x__017_) ->
                                    Sexplib.Sexp.t -> 'v_x__017_ t
                                end
                            val t_of_sexp :
                              (Base__.Sexplib.Sexp.t -> 'a) ->
                              Base__.Sexplib.Sexp.t -> 'a t
                            val sexp_of_t :
                              ('-> Base__.Sexplib.Sexp.t) ->
                              'a t -> Base__.Sexplib.Sexp.t
                          end
                        type 'a t =
                            (node, 'a, comparator_witness)
                            Core_kernel__.Core_map_intf.Map.t
                        val compare :
                          ('-> '-> Core_kernel__.Import.int) ->
                          'a t -> 'a t -> Core_kernel__.Import.int
                        val empty : 'a t
                        val singleton : node -> '-> 'a t
                        val of_alist :
                          (node * 'a) list ->
                          [ `Duplicate_key of node | `Ok of 'a t ]
                        val of_alist_or_error :
                          (node * 'a) list -> 'a t Base__.Or_error.t
                        val of_alist_exn : (node * 'a) list -> 'a t
                        val of_alist_multi : (node * 'a) list -> 'a list t
                        val of_alist_fold :
                          (node * 'a) list ->
                          init:'-> f:('-> '-> 'b) -> 'b t
                        val of_alist_reduce :
                          (node * 'a) list -> f:('-> '-> 'a) -> 'a t
                        val of_sorted_array :
                          (node * 'a) array -> 'a t Base__.Or_error.t
                        val of_sorted_array_unchecked :
                          (node * 'a) array -> 'a t
                        val of_increasing_iterator_unchecked :
                          len:int -> f:(int -> node * 'a) -> 'a t
                        val of_iteri :
                          iteri:(f:(key:node -> data:'-> unit) -> unit) ->
                          [ `Duplicate_key of node | `Ok of 'v t ]
                        val of_tree : 'Tree.t -> 'a t
                        val of_hashtbl_exn :
                          (node, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                        val gen :
                          node Core_kernel__.Quickcheck.Generator.t ->
                          'Core_kernel__.Quickcheck.Generator.t ->
                          'a t Core_kernel__.Quickcheck.Generator.t
                        val invariants : 'a t -> bool
                        val is_empty : 'a t -> bool
                        val length : 'a t -> int
                        val add : 'a t -> key:node -> data:'-> 'a t
                        val add_multi :
                          'a list t -> key:node -> data:'-> 'a list t
                        val remove_multi : 'a list t -> node -> 'a list t
                        val change :
                          'a t -> node -> f:('a option -> 'a option) -> 'a t
                        val update :
                          'a t -> node -> f:('a option -> 'a) -> 'a t
                        val find : 'a t -> node -> 'a option
                        val find_exn : 'a t -> node -> 'a
                        val remove : 'a t -> node -> 'a t
                        val mem : 'a t -> node -> bool
                        val iter_keys : 'a t -> f:(node -> unit) -> unit
                        val iter : 'a t -> f:('-> unit) -> unit
                        val iteri :
                          'a t -> f:(key:node -> data:'-> unit) -> unit
                        val iter2 :
                          'a t ->
                          'b t ->
                          f:(key:node ->
                             data:[ `Both of 'a * 'b
                                  | `Left of 'a
                                  | `Right of 'b ] ->
                             unit) ->
                          unit
                        val map : 'a t -> f:('-> 'b) -> 'b t
                        val mapi :
                          'a t -> f:(key:node -> data:'-> 'b) -> 'b t
                        val fold :
                          'a t ->
                          init:'->
                          f:(key:node -> data:'-> '-> 'b) -> 'b
                        val fold_right :
                          'a t ->
                          init:'->
                          f:(key:node -> data:'-> '-> 'b) -> 'b
                        val fold2 :
                          'a t ->
                          'b t ->
                          init:'->
                          f:(key:node ->
                             data:[ `Both of 'a * 'b
                                  | `Left of 'a
                                  | `Right of 'b ] ->
                             '-> 'c) ->
                          'c
                        val filter_keys : 'a t -> f:(node -> bool) -> 'a t
                        val filter : 'a t -> f:('-> bool) -> 'a t
                        val filteri :
                          'a t -> f:(key:node -> data:'-> bool) -> 'a t
                        val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                        val filter_mapi :
                          'a t ->
                          f:(key:node -> data:'-> 'b option) -> 'b t
                        val partition_mapi :
                          'a t ->
                          f:(key:node ->
                             data:'-> [ `Fst of '| `Snd of 'c ]) ->
                          'b t * 'c t
                        val partition_map :
                          'a t ->
                          f:('-> [ `Fst of '| `Snd of 'c ]) ->
                          'b t * 'c t
                        val partitioni_tf :
                          'a t ->
                          f:(key:node -> data:'-> bool) -> 'a t * 'a t
                        val partition_tf :
                          'a t -> f:('-> bool) -> 'a t * 'a t
                        val compare_direct :
                          ('-> '-> int) -> 'a t -> 'a t -> int
                        val equal :
                          ('-> '-> bool) -> 'a t -> 'a t -> bool
                        val keys : 'a t -> node list
                        val data : 'a t -> 'a list
                        val to_alist :
                          ?key_order:[ `Decreasing | `Increasing ] ->
                          'a t -> (node * 'a) list
                        val validate :
                          name:(node -> string) ->
                          'Base__.Validate.check ->
                          'a t Base__.Validate.check
                        val merge :
                          'a t ->
                          'b t ->
                          f:(key:node ->
                             [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                             'c option) ->
                          'c t
                        val symmetric_diff :
                          'a t ->
                          'a t ->
                          data_equal:('-> '-> bool) ->
                          (node, 'a)
                          Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                          Base__.Sequence.t
                        val min_elt : 'a t -> (node * 'a) option
                        val min_elt_exn : 'a t -> node * 'a
                        val max_elt : 'a t -> (node * 'a) option
                        val max_elt_exn : 'a t -> node * 'a
                        val for_all : 'a t -> f:('-> bool) -> bool
                        val for_alli :
                          'a t -> f:(key:node -> data:'-> bool) -> bool
                        val exists : 'a t -> f:('-> bool) -> bool
                        val existsi :
                          'a t -> f:(key:node -> data:'-> bool) -> bool
                        val count : 'a t -> f:('-> bool) -> int
                        val counti :
                          'a t -> f:(key:node -> data:'-> bool) -> int
                        val split :
                          'a t -> node -> 'a t * (node * 'a) option * 'a t
                        val append :
                          lower_part:'a t ->
                          upper_part:'a t ->
                          [ `Ok of 'a t | `Overlapping_key_ranges ]
                        val subrange :
                          'a t ->
                          lower_bound:node Base__.Maybe_bound.t ->
                          upper_bound:node Base__.Maybe_bound.t -> 'a t
                        val fold_range_inclusive :
                          'a t ->
                          min:node ->
                          max:node ->
                          init:'->
                          f:(key:node -> data:'-> '-> 'b) -> 'b
                        val range_to_alist :
                          'a t -> min:node -> max:node -> (node * 'a) list
                        val closest_key :
                          'a t ->
                          [ `Greater_or_equal_to
                          | `Greater_than
                          | `Less_or_equal_to
                          | `Less_than ] -> node -> (node * 'a) option
                        val nth : 'a t -> int -> (node * 'a) option
                        val nth_exn : 'a t -> int -> node * 'a
                        val rank : 'a t -> node -> int option
                        val to_tree : 'a t -> 'Tree.t
                        val to_sequence :
                          ?order:[ `Decreasing_key | `Increasing_key ] ->
                          ?keys_greater_or_equal_to:node ->
                          ?keys_less_or_equal_to:node ->
                          'a t -> (node * 'a) Base__.Sequence.t
                        val obs :
                          node Core_kernel__.Quickcheck.Observer.t ->
                          'Core_kernel__.Quickcheck.Observer.t ->
                          'v t Core_kernel__.Quickcheck.Observer.t
                        val shrinker :
                          node Core_kernel__.Quickcheck.Shrinker.t ->
                          'Core_kernel__.Quickcheck.Shrinker.t ->
                          'v t Core_kernel__.Quickcheck.Shrinker.t
                        module Provide_of_sexp :
                          functor
                            (Key : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> node
                                   end->
                            sig
                              val t_of_sexp :
                                (Sexplib.Sexp.t -> 'v_x__018_) ->
                                Sexplib.Sexp.t -> 'v_x__018_ t
                            end
                        module Provide_bin_io :
                          functor
                            (Key : sig
                                     val bin_t : node Bin_prot.Type_class.t
                                     val bin_read_t :
                                       node Bin_prot.Read.reader
                                     val __bin_read_t__ :
                                       (Core_kernel__.Import.int -> node)
                                       Bin_prot.Read.reader
                                     val bin_reader_t :
                                       node Bin_prot.Type_class.reader
                                     val bin_size_t :
                                       node Bin_prot.Size.sizer
                                     val bin_write_t :
                                       node Bin_prot.Write.writer
                                     val bin_writer_t :
                                       node Bin_prot.Type_class.writer
                                     val bin_shape_t : Bin_prot.Shape.t
                                   end->
                            sig
                              val bin_shape_t :
                                Bin_prot.Shape.t -> Bin_prot.Shape.t
                              val bin_size_t :
                                ('a, 'a t) Bin_prot.Size.sizer1
                              val bin_write_t :
                                ('a, 'a t) Bin_prot.Write.writer1
                              val bin_read_t :
                                ('a, 'a t) Bin_prot.Read.reader1
                              val __bin_read_t__ :
                                ('a, int -> 'a t) Bin_prot.Read.reader1
                              val bin_writer_t :
                                ('a, 'a t) Bin_prot.Type_class.S1.writer
                              val bin_reader_t :
                                ('a, 'a t) Bin_prot.Type_class.S1.reader
                              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                            end
                        module Provide_hash :
                          functor
                            (Key : sig
                                     val hash_fold_t :
                                       Base__.Hash.state ->
                                       node -> Base__.Hash.state
                                   end->
                            sig
                              val hash_fold_t :
                                (Ppx_hash_lib.Std.Hash.state ->
                                 '-> Ppx_hash_lib.Std.Hash.state) ->
                                Ppx_hash_lib.Std.Hash.state ->
                                'a t -> Ppx_hash_lib.Std.Hash.state
                            end
                        val t_of_sexp :
                          (Base__.Sexplib.Sexp.t -> 'a) ->
                          Base__.Sexplib.Sexp.t -> 'a t
                        val sexp_of_t :
                          ('-> Base__.Sexplib.Sexp.t) ->
                          'a t -> Base__.Sexplib.Sexp.t
                      end
                    module Set :
                      sig
                        module Elt :
                          sig
                            type t = node
                            val t_of_sexp : Sexplib.Sexp.t -> t
                            val sexp_of_t : t -> Sexplib.Sexp.t
                            type comparator_witness =
                                Map.Key.comparator_witness
                            val comparator :
                              (t, comparator_witness)
                              Core_kernel__.Comparator.comparator
                          end
                        module Tree :
                          sig
                            type t =
                                (node, comparator_witness)
                                Core_kernel__.Core_set_intf.Tree.t
                            val compare : t -> t -> Core_kernel__.Import.int
                            val length : t -> int
                            val is_empty : t -> bool
                            val iter : t -> f:(node -> unit) -> unit
                            val fold :
                              t ->
                              init:'accum ->
                              f:('accum -> node -> 'accum) -> 'accum
                            val fold_result :
                              t ->
                              init:'accum ->
                              f:('accum ->
                                 node -> ('accum, 'e) Base__.Result.t) ->
                              ('accum, 'e) Base__.Result.t
                            val exists : t -> f:(node -> bool) -> bool
                            val for_all : t -> f:(node -> bool) -> bool
                            val count : t -> f:(node -> bool) -> int
                            val sum :
                              (module Base__.Commutative_group.S with type t = 'sum) ->
                              t -> f:(node -> 'sum) -> 'sum
                            val find : t -> f:(node -> bool) -> node option
                            val find_map :
                              t -> f:(node -> 'a option) -> 'a option
                            val to_list : t -> node list
                            val to_array : t -> node array
                            val invariants : t -> bool
                            val mem : t -> node -> bool
                            val add : t -> node -> t
                            val remove : t -> node -> t
                            val union : t -> t -> t
                            val inter : t -> t -> t
                            val diff : t -> t -> t
                            val symmetric_diff :
                              t ->
                              t ->
                              (node, node) Base__.Either.t Base__.Sequence.t
                            val compare_direct : t -> t -> int
                            val equal : t -> t -> bool
                            val is_subset : t -> of_:t -> bool
                            val subset : t -> t -> bool
                            val fold_until :
                              t ->
                              init:'->
                              f:('->
                                 node ->
                                 ('b, 'stop)
                                 Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                              ('b, 'stop)
                              Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                            val fold_right :
                              t -> init:'-> f:(node -> '-> 'b) -> 'b
                            val iter2 :
                              t ->
                              t ->
                              f:([ `Both of node * node
                                 | `Left of node
                                 | `Right of node ] -> unit) ->
                              unit
                            val filter : t -> f:(node -> bool) -> t
                            val partition_tf : t -> f:(node -> bool) -> t * t
                            val elements : t -> node list
                            val min_elt : t -> node option
                            val min_elt_exn : t -> node
                            val max_elt : t -> node option
                            val max_elt_exn : t -> node
                            val choose : t -> node option
                            val choose_exn : t -> node
                            val split : t -> node -> t * node option * t
                            val group_by :
                              t -> equiv:(node -> node -> bool) -> t list
                            val find_exn : t -> f:(node -> bool) -> node
                            val find_index : t -> int -> node option
                            val nth : t -> int -> node option
                            val remove_index : t -> int -> t
                            val to_tree : t -> t
                            val to_sequence :
                              ?order:[ `Decreasing | `Increasing ] ->
                              ?greater_or_equal_to:node ->
                              ?less_or_equal_to:node ->
                              t -> node Base__.Sequence.t
                            val merge_to_sequence :
                              ?order:[ `Decreasing | `Increasing ] ->
                              ?greater_or_equal_to:node ->
                              ?less_or_equal_to:node ->
                              t ->
                              t ->
                              (node, node)
                              Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                              Base__.Sequence.t
                            val to_map :
                              t ->
                              f:(node -> 'data) ->
                              (node, 'data, comparator_witness)
                              Core_kernel__.Core_set_intf.Map.t
                            val obs :
                              node Core_kernel__.Quickcheck.Observer.t ->
                              t Core_kernel__.Quickcheck.Observer.t
                            val shrinker :
                              node Core_kernel__.Quickcheck.Shrinker.t ->
                              t Core_kernel__.Quickcheck.Shrinker.t
                            val empty : t
                            val singleton : node -> t
                            val union_list : t list -> t
                            val of_list : node list -> t
                            val of_array : node array -> t
                            val of_sorted_array :
                              node array -> t Base__.Or_error.t
                            val of_sorted_array_unchecked : node array -> t
                            val of_increasing_iterator_unchecked :
                              len:int -> f:(int -> node) -> t
                            val stable_dedup_list : node list -> node list
                            val map :
                              ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                              f:('-> node) -> t
                            val filter_map :
                              ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                              f:('-> node option) -> t
                            val of_tree : t -> t
                            val of_hash_set :
                              node Core_kernel__.Hash_set.t -> t
                            val of_hashtbl_keys :
                              (node, 'a) Core_kernel__.Core_hashtbl.t -> t
                            val of_map_keys :
                              (node, 'a, comparator_witness)
                              Core_kernel__.Core_set_intf.Map.t -> t
                            val gen :
                              node Core_kernel__.Quickcheck.Generator.t ->
                              t Core_kernel__.Quickcheck.Generator.t
                            module Provide_of_sexp :
                              functor
                                (Elt : sig
                                         val t_of_sexp :
                                           Sexplib.Sexp.t -> node
                                       end->
                                sig val t_of_sexp : Sexplib.Sexp.t -> t end
                            val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                            val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                          end
                        type t = (node, comparator_witness) Base.Set.t
                        val compare : t -> t -> Core_kernel__.Import.int
                        val length : t -> int
                        val is_empty : t -> bool
                        val iter : t -> f:(node -> unit) -> unit
                        val fold :
                          t ->
                          init:'accum ->
                          f:('accum -> node -> 'accum) -> 'accum
                        val fold_result :
                          t ->
                          init:'accum ->
                          f:('accum -> node -> ('accum, 'e) Base__.Result.t) ->
                          ('accum, 'e) Base__.Result.t
                        val exists : t -> f:(node -> bool) -> bool
                        val for_all : t -> f:(node -> bool) -> bool
                        val count : t -> f:(node -> bool) -> int
                        val sum :
                          (module Base__.Commutative_group.S with type t = 'sum) ->
                          t -> f:(node -> 'sum) -> 'sum
                        val find : t -> f:(node -> bool) -> node option
                        val find_map :
                          t -> f:(node -> 'a option) -> 'a option
                        val to_list : t -> node list
                        val to_array : t -> node array
                        val invariants : t -> bool
                        val mem : t -> node -> bool
                        val add : t -> node -> t
                        val remove : t -> node -> t
                        val union : t -> t -> t
                        val inter : t -> t -> t
                        val diff : t -> t -> t
                        val symmetric_diff :
                          t ->
                          t -> (node, node) Base__.Either.t Base__.Sequence.t
                        val compare_direct : t -> t -> int
                        val equal : t -> t -> bool
                        val is_subset : t -> of_:t -> bool
                        val subset : t -> t -> bool
                        val fold_until :
                          t ->
                          init:'->
                          f:('->
                             node ->
                             ('b, 'stop)
                             Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                          ('b, 'stop)
                          Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                        val fold_right :
                          t -> init:'-> f:(node -> '-> 'b) -> 'b
                        val iter2 :
                          t ->
                          t ->
                          f:([ `Both of node * node
                             | `Left of node
                             | `Right of node ] -> unit) ->
                          unit
                        val filter : t -> f:(node -> bool) -> t
                        val partition_tf : t -> f:(node -> bool) -> t * t
                        val elements : t -> node list
                        val min_elt : t -> node option
                        val min_elt_exn : t -> node
                        val max_elt : t -> node option
                        val max_elt_exn : t -> node
                        val choose : t -> node option
                        val choose_exn : t -> node
                        val split : t -> node -> t * node option * t
                        val group_by :
                          t -> equiv:(node -> node -> bool) -> t list
                        val find_exn : t -> f:(node -> bool) -> node
                        val find_index : t -> int -> node option
                        val nth : t -> int -> node option
                        val remove_index : t -> int -> t
                        val to_tree : t -> Tree.t
                        val to_sequence :
                          ?order:[ `Decreasing | `Increasing ] ->
                          ?greater_or_equal_to:node ->
                          ?less_or_equal_to:node ->
                          t -> node Base__.Sequence.t
                        val merge_to_sequence :
                          ?order:[ `Decreasing | `Increasing ] ->
                          ?greater_or_equal_to:node ->
                          ?less_or_equal_to:node ->
                          t ->
                          t ->
                          (node, node)
                          Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                          Base__.Sequence.t
                        val to_map :
                          t ->
                          f:(node -> 'data) ->
                          (node, 'data, comparator_witness)
                          Core_kernel__.Core_set_intf.Map.t
                        val obs :
                          node Core_kernel__.Quickcheck.Observer.t ->
                          t Core_kernel__.Quickcheck.Observer.t
                        val shrinker :
                          node Core_kernel__.Quickcheck.Shrinker.t ->
                          t Core_kernel__.Quickcheck.Shrinker.t
                        val empty : t
                        val singleton : node -> t
                        val union_list : t list -> t
                        val of_list : node list -> t
                        val of_array : node array -> t
                        val of_sorted_array :
                          node array -> t Base__.Or_error.t
                        val of_sorted_array_unchecked : node array -> t
                        val of_increasing_iterator_unchecked :
                          len:int -> f:(int -> node) -> t
                        val stable_dedup_list : node list -> node list
                        val map : ('a, 'b) Base.Set.t -> f:('-> node) -> t
                        val filter_map :
                          ('a, 'b) Base.Set.t -> f:('-> node option) -> t
                        val of_tree : Tree.t -> t
                        val of_hash_set : node Core_kernel__.Hash_set.t -> t
                        val of_hashtbl_keys :
                          (node, 'a) Core_kernel__.Core_hashtbl.t -> t
                        val of_map_keys :
                          (node, 'a, comparator_witness)
                          Core_kernel__.Core_set_intf.Map.t -> t
                        val gen :
                          node Core_kernel__.Quickcheck.Generator.t ->
                          t Core_kernel__.Quickcheck.Generator.t
                        module Provide_of_sexp :
                          functor
                            (Elt : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> node
                                   end->
                            sig val t_of_sexp : Sexplib.Sexp.t -> t end
                        module Provide_bin_io :
                          functor
                            (Elt : sig
                                     val bin_t : node Bin_prot.Type_class.t
                                     val bin_read_t :
                                       node Bin_prot.Read.reader
                                     val __bin_read_t__ :
                                       (Core_kernel__.Import.int -> node)
                                       Bin_prot.Read.reader
                                     val bin_reader_t :
                                       node Bin_prot.Type_class.reader
                                     val bin_size_t :
                                       node Bin_prot.Size.sizer
                                     val bin_write_t :
                                       node Bin_prot.Write.writer
                                     val bin_writer_t :
                                       node Bin_prot.Type_class.writer
                                     val bin_shape_t : Bin_prot.Shape.t
                                   end->
                            sig
                              val bin_size_t : t Bin_prot.Size.sizer
                              val bin_write_t : t Bin_prot.Write.writer
                              val bin_read_t : t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                (int -> t) Bin_prot.Read.reader
                              val bin_shape_t : Bin_prot.Shape.t
                              val bin_writer_t : t Bin_prot.Type_class.writer
                              val bin_reader_t : t Bin_prot.Type_class.reader
                              val bin_t : t Bin_prot.Type_class.t
                            end
                        module Provide_hash :
                          functor
                            (Elt : sig
                                     val hash_fold_t :
                                       Base__.Hash.state ->
                                       node -> Base__.Hash.state
                                   end->
                            sig
                              val hash_fold_t :
                                Ppx_hash_lib.Std.Hash.state ->
                                t -> Ppx_hash_lib.Std.Hash.state
                              val hash :
                                t -> Ppx_hash_lib.Std.Hash.hash_value
                            end
                        val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                        val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                      end
                    val hash : t -> Core_kernel__.Import.int
                    val compare : t -> t -> Core_kernel__.Import.int
                    val hashable :
                      t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
                    module Table :
                      sig
                        type key = t
                        type ('a, 'b) hashtbl = ('a, 'b) G.Table.hashtbl
                        type 'b t = (key, 'b) hashtbl
                        val sexp_of_t :
                          ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                        type ('a, 'b) t_ = 'b t
                        type 'a key_ = key
                        val hashable :
                          key Core_kernel__.Core_hashtbl_intf.Hashable.t
                        val invariant :
                          'Base__.Invariant_intf.inv ->
                          'a t Base__.Invariant_intf.inv
                        val create :
                          (key, 'b, unit -> 'b t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist :
                          (key, 'b,
                           (key * 'b) list ->
                           [ `Duplicate_key of key | `Ok of 'b t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_report_all_dups :
                          (key, 'b,
                           (key * 'b) list ->
                           [ `Duplicate_keys of key list | `Ok of 'b t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_or_error :
                          (key, 'b,
                           (key * 'b) list -> 'b t Base__.Or_error.t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_exn :
                          (key, 'b, (key * 'b) list -> 'b t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_multi :
                          (key, 'b list, (key * 'b) list -> 'b list t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_mapped :
                          (key, 'b,
                           get_key:('-> key) ->
                           get_data:('-> 'b) ->
                           'r list ->
                           [ `Duplicate_keys of key list | `Ok of 'b t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_with_key :
                          (key, 'r,
                           get_key:('-> key) ->
                           'r list ->
                           [ `Duplicate_keys of key list | `Ok of 'r t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_with_key_or_error :
                          (key, 'r,
                           get_key:('-> key) ->
                           'r list -> 'r t Base__.Or_error.t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_with_key_exn :
                          (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val group :
                          (key, 'b,
                           get_key:('-> key) ->
                           get_data:('-> 'b) ->
                           combine:('-> '-> 'b) -> 'r list -> 'b t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                        val clear : 'a t -> unit
                        val copy : 'b t -> 'b t
                        val fold :
                          'b t ->
                          init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                        val iter_keys : 'a t -> f:(key -> unit) -> unit
                        val iter : 'b t -> f:('-> unit) -> unit
                        val iteri :
                          'b t -> f:(key:key -> data:'-> unit) -> unit
                        val iter_vals : 'b t -> f:('-> unit) -> unit
                        val existsi :
                          'b t -> f:(key:key -> data:'-> bool) -> bool
                        val exists : 'b t -> f:('-> bool) -> bool
                        val for_alli :
                          'b t -> f:(key:key -> data:'-> bool) -> bool
                        val for_all : 'b t -> f:('-> bool) -> bool
                        val counti :
                          'b t -> f:(key:key -> data:'-> bool) -> int
                        val count : 'b t -> f:('-> bool) -> int
                        val length : 'a t -> int
                        val is_empty : 'a t -> bool
                        val mem : 'a t -> key -> bool
                        val remove : 'a t -> key -> unit
                        val replace : 'b t -> key:key -> data:'-> unit
                        val set : 'b t -> key:key -> data:'-> unit
                        val add :
                          'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                        val add_or_error :
                          'b t ->
                          key:key -> data:'-> unit Base__.Or_error.t
                        val add_exn : 'b t -> key:key -> data:'-> unit
                        val change :
                          'b t -> key -> f:('b option -> 'b option) -> unit
                        val update :
                          'b t -> key -> f:('b option -> 'b) -> unit
                        val add_multi :
                          'b list t -> key:key -> data:'-> unit
                        val remove_multi : 'a list t -> key -> unit
                        val map : 'b t -> f:('-> 'c) -> 'c t
                        val mapi :
                          'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                        val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                        val filter_mapi :
                          'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                        val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                        val filter : 'b t -> f:('-> bool) -> 'b t
                        val filteri :
                          'b t -> f:(key:key -> data:'-> bool) -> 'b t
                        val partition_map :
                          'b t ->
                          f:('-> [ `Fst of '| `Snd of 'd ]) ->
                          'c t * 'd t
                        val partition_mapi :
                          'b t ->
                          f:(key:key ->
                             data:'-> [ `Fst of '| `Snd of 'd ]) ->
                          'c t * 'd t
                        val partition_tf :
                          'b t -> f:('-> bool) -> 'b t * 'b t
                        val partitioni_tf :
                          'b t ->
                          f:(key:key -> data:'-> bool) -> 'b t * 'b t
                        val find_or_add :
                          'b t -> key -> default:(unit -> 'b) -> 'b
                        val find : 'b t -> key -> 'b option
                        val find_exn : 'b t -> key -> 'b
                        val find_and_call :
                          'b t ->
                          key ->
                          if_found:('-> 'c) ->
                          if_not_found:(key -> 'c) -> 'c
                        val find_and_remove : 'b t -> key -> 'b option
                        val merge :
                          'a t ->
                          'b t ->
                          f:(key:key ->
                             [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                             'c option) ->
                          'c t
                        type 'a merge_into_action = Remove | Set_to of 'a
                        val merge_into :
                          src:'a t ->
                          dst:'b t ->
                          f:(key:key ->
                             '-> 'b option -> 'b merge_into_action) ->
                          unit
                        val keys : 'a t -> key list
                        val data : 'b t -> 'b list
                        val filter_keys_inplace :
                          'a t -> f:(key -> bool) -> unit
                        val filter_inplace : 'b t -> f:('-> bool) -> unit
                        val filteri_inplace :
                          'b t -> f:(key:key -> data:'-> bool) -> unit
                        val map_inplace : 'b t -> f:('-> 'b) -> unit
                        val mapi_inplace :
                          'b t -> f:(key:key -> data:'-> 'b) -> unit
                        val filter_map_inplace :
                          'b t -> f:('-> 'b option) -> unit
                        val filter_mapi_inplace :
                          'b t -> f:(key:key -> data:'-> 'b option) -> unit
                        val replace_all : 'b t -> f:('-> 'b) -> unit
                        val replace_alli :
                          'b t -> f:(key:key -> data:'-> 'b) -> unit
                        val filter_replace_all :
                          'b t -> f:('-> 'b option) -> unit
                        val filter_replace_alli :
                          'b t -> f:(key:key -> data:'-> 'b option) -> unit
                        val equal :
                          'b t -> 'b t -> ('-> '-> bool) -> bool
                        val similar :
                          'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                        val to_alist : 'b t -> (key * 'b) list
                        val validate :
                          name:(key -> string) ->
                          'Base__.Validate.check ->
                          'b t Base__.Validate.check
                        val incr :
                          ?by:int ->
                          ?remove_if_zero:bool -> int t -> key -> unit
                        val decr :
                          ?by:int ->
                          ?remove_if_zero:bool -> int t -> key -> unit
                        module Provide_of_sexp :
                          functor
                            (Key : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> key
                                   end->
                            sig
                              val t_of_sexp :
                                (Sexplib.Sexp.t -> 'v_x__001_) ->
                                Sexplib.Sexp.t -> 'v_x__001_ t
                            end
                        module Provide_bin_io :
                          functor
                            (Key : sig
                                     val bin_t : key Bin_prot.Type_class.t
                                     val bin_read_t :
                                       key Bin_prot.Read.reader
                                     val __bin_read_t__ :
                                       (Core_kernel__.Import.int -> key)
                                       Bin_prot.Read.reader
                                     val bin_reader_t :
                                       key Bin_prot.Type_class.reader
                                     val bin_size_t : key Bin_prot.Size.sizer
                                     val bin_write_t :
                                       key Bin_prot.Write.writer
                                     val bin_writer_t :
                                       key Bin_prot.Type_class.writer
                                     val bin_shape_t : Bin_prot.Shape.t
                                   end->
                            sig
                              val bin_t :
                                'Bin_prot.Type_class.t ->
                                'a t Bin_prot.Type_class.t
                              val bin_read_t :
                                'Bin_prot.Read.reader ->
                                'a t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                'Bin_prot.Read.reader ->
                                (Core_kernel__.Import.int -> 'a t)
                                Bin_prot.Read.reader
                              val bin_reader_t :
                                'Bin_prot.Type_class.reader ->
                                'a t Bin_prot.Type_class.reader
                              val bin_size_t :
                                'Bin_prot.Size.sizer ->
                                'a t Bin_prot.Size.sizer
                              val bin_write_t :
                                'Bin_prot.Write.writer ->
                                'a t Bin_prot.Write.writer
                              val bin_writer_t :
                                'Bin_prot.Type_class.writer ->
                                'a t Bin_prot.Type_class.writer
                              val bin_shape_t :
                                Bin_prot.Shape.t -> Bin_prot.Shape.t
                            end
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__002_) ->
                          Sexplib.Sexp.t -> 'v_x__002_ t
                      end
                    module Hash_set :
                      sig
                        type elt = t
                        type t = elt Core_kernel__.Hash_set.t
                        val sexp_of_t : t -> Sexplib.Sexp.t
                        type 'a t_ = t
                        type 'a elt_ = elt
                        val create :
                          ('a, unit -> t)
                          Core_kernel__.Hash_set_intf.create_options_without_hashable
                        val of_list :
                          ('a, elt list -> t)
                          Core_kernel__.Hash_set_intf.create_options_without_hashable
                        module Provide_of_sexp :
                          functor
                            (X : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> elt
                                 end->
                            sig val t_of_sexp : Sexplib.Sexp.t -> t end
                        module Provide_bin_io :
                          functor
                            (X : sig
                                   val bin_t : elt Bin_prot.Type_class.t
                                   val bin_read_t : elt Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> elt)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     elt Bin_prot.Type_class.reader
                                   val bin_size_t : elt Bin_prot.Size.sizer
                                   val bin_write_t :
                                     elt Bin_prot.Write.writer
                                   val bin_writer_t :
                                     elt Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                            sig
                              val bin_t : t Bin_prot.Type_class.t
                              val bin_read_t : t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                (Core_kernel__.Import.int -> t)
                                Bin_prot.Read.reader
                              val bin_reader_t : t Bin_prot.Type_class.reader
                              val bin_size_t : t Bin_prot.Size.sizer
                              val bin_write_t : t Bin_prot.Write.writer
                              val bin_writer_t : t Bin_prot.Type_class.writer
                              val bin_shape_t : Bin_prot.Shape.t
                            end
                        val t_of_sexp : Sexplib.Sexp.t -> t
                      end
                    module Hash_queue :
                      sig
                        module Key :
                          sig
                            type t = node
                            val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                            val compare : t -> t -> int
                            val hash : t -> int
                          end
                        type 'a t
                        val sexp_of_t :
                          ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                        val length : 'a t -> int
                        val is_empty : 'a t -> bool
                        val iter : 'a t -> f:('-> unit) -> unit
                        val fold :
                          'a t ->
                          init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                        val fold_result :
                          'a t ->
                          init:'accum ->
                          f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                          ('accum, 'e) Base__.Result.t
                        val fold_until :
                          'a t ->
                          init:'accum ->
                          f:('accum ->
                             '->
                             ('accum, 'stop)
                             Base.Container_intf.Continue_or_stop.t) ->
                          ('accum, 'stop)
                          Base.Container_intf.Finished_or_stopped_early.t
                        val exists : 'a t -> f:('-> bool) -> bool
                        val for_all : 'a t -> f:('-> bool) -> bool
                        val count : 'a t -> f:('-> bool) -> int
                        val sum :
                          (module Base__.Commutative_group.S with type t = 'sum) ->
                          'a t -> f:('-> 'sum) -> 'sum
                        val find : 'a t -> f:('-> bool) -> 'a option
                        val find_map :
                          'a t -> f:('-> 'b option) -> 'b option
                        val to_list : 'a t -> 'a list
                        val to_array : 'a t -> 'a array
                        val min_elt :
                          'a t -> cmp:('-> '-> int) -> 'a option
                        val max_elt :
                          'a t -> cmp:('-> '-> int) -> 'a option
                        val invariant : 'a t -> Core_kernel__.Import.unit
                        val create :
                          ?growth_allowed:Core_kernel__.Import.bool ->
                          ?size:Core_kernel__.Import.int ->
                          Core_kernel__.Import.unit -> 'a t
                        val clear : 'a t -> Core_kernel__.Import.unit
                        val mem : 'a t -> node -> Core_kernel__.Import.bool
                        val lookup :
                          'a t -> node -> 'Core_kernel__.Import.option
                        val lookup_exn : 'a t -> node -> 'a
                        val enqueue :
                          'a t ->
                          node -> '-> [ `Key_already_present | `Ok ]
                        val enqueue_exn :
                          'a t -> node -> '-> Core_kernel__.Import.unit
                        val lookup_and_move_to_back :
                          'a t -> node -> 'Core_kernel__.Import.option
                        val lookup_and_move_to_back_exn : 'a t -> node -> 'a
                        val first : 'a t -> 'Core_kernel__.Import.option
                        val first_with_key :
                          'a t -> (node * 'a) Core_kernel__.Import.option
                        val keys : 'a t -> node Core_kernel__.Import.list
                        val dequeue : 'a t -> 'Core_kernel__.Import.option
                        val dequeue_exn : 'a t -> 'a
                        val dequeue_with_key :
                          'a t -> (node * 'a) Core_kernel__.Import.option
                        val dequeue_with_key_exn : 'a t -> node * 'a
                        val dequeue_all :
                          'a t ->
                          f:('-> Core_kernel__.Import.unit) ->
                          Core_kernel__.Import.unit
                        val remove : 'a t -> node -> [ `No_such_key | `Ok ]
                        val remove_exn :
                          'a t -> node -> Core_kernel__.Import.unit
                        val replace :
                          'a t -> node -> '-> [ `No_such_key | `Ok ]
                        val replace_exn :
                          'a t -> node -> '-> Core_kernel__.Import.unit
                        val iteri :
                          'a t ->
                          f:(key:node -> data:'-> Core_kernel__.Import.unit) ->
                          Core_kernel__.Import.unit
                        val foldi :
                          'a t ->
                          init:'->
                          f:('-> key:node -> data:'-> 'b) -> 'b
                      end
                  end
                module Edge :
                  sig
                    type t = edge
                    type node = Node.t
                    type graph = Node.graph
                    type label = EL.t
                    val create : node -> node -> label -> t
                    val label : t -> label
                    val src : t -> node
                    val dst : t -> node
                    val mem : t -> graph -> bool
                    val insert : t -> graph -> graph
                    val update : t -> label -> graph -> graph
                    val remove : t -> graph -> graph
                    val ( >= ) : t -> t -> bool
                    val ( <= ) : t -> t -> bool
                    val ( = ) : t -> t -> bool
                    val ( > ) : t -> t -> bool
                    val ( < ) : t -> t -> bool
                    val ( <> ) : t -> t -> bool
                    val equal : t -> t -> bool
                    val min : t -> t -> t
                    val max : t -> t -> t
                    val ascending : t -> t -> int
                    val descending : t -> t -> int
                    val between : t -> low:t -> high:t -> bool
                    val clamp_exn : t -> min:t -> max:t -> t
                    val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
                    type comparator_witness
                    val comparator :
                      (t, comparator_witness) Base__.Comparator.comparator
                    val validate_lbound :
                      min:t Base__.Maybe_bound.t -> t Base__.Validate.check
                    val validate_ubound :
                      max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                    val validate_bound :
                      min:t Base__.Maybe_bound.t ->
                      max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                    module Replace_polymorphic_compare :
                      sig
                        val ( >= ) : t -> t -> bool
                        val ( <= ) : t -> t -> bool
                        val ( = ) : t -> t -> bool
                        val ( > ) : t -> t -> bool
                        val ( < ) : t -> t -> bool
                        val ( <> ) : t -> t -> bool
                        val equal : t -> t -> bool
                        val compare : t -> t -> int
                        val min : t -> t -> t
                        val max : t -> t -> t
                      end
                    module Map :
                      sig
                        module Key :
                          sig
                            type t = edge
                            val t_of_sexp : Sexplib.Sexp.t -> t
                            val sexp_of_t : t -> Sexplib.Sexp.t
                            type comparator_witness = comparator_witness
                            val comparator :
                              (t, comparator_witness)
                              Core_kernel__.Comparator.comparator
                          end
                        module Tree :
                          sig
                            type 'a t =
                                (edge, 'a, comparator_witness)
                                Core_kernel__.Core_map_intf.Tree.t
                            val empty : 'a t
                            val singleton : edge -> '-> 'a t
                            val of_alist :
                              (edge * 'a) list ->
                              [ `Duplicate_key of edge | `Ok of 'a t ]
                            val of_alist_or_error :
                              (edge * 'a) list -> 'a t Base__.Or_error.t
                            val of_alist_exn : (edge * 'a) list -> 'a t
                            val of_alist_multi :
                              (edge * 'a) list -> 'a list t
                            val of_alist_fold :
                              (edge * 'a) list ->
                              init:'-> f:('-> '-> 'b) -> 'b t
                            val of_alist_reduce :
                              (edge * 'a) list -> f:('-> '-> 'a) -> 'a t
                            val of_sorted_array :
                              (edge * 'a) array -> 'a t Base__.Or_error.t
                            val of_sorted_array_unchecked :
                              (edge * 'a) array -> 'a t
                            val of_increasing_iterator_unchecked :
                              len:int -> f:(int -> edge * 'a) -> 'a t
                            val of_iteri :
                              iteri:(f:(key:edge -> data:'-> unit) -> unit) ->
                              [ `Duplicate_key of edge | `Ok of 'v t ]
                            val of_tree : 'a t -> 'a t
                            val of_hashtbl_exn :
                              (edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                            val gen :
                              edge Core_kernel__.Quickcheck.Generator.t ->
                              'Core_kernel__.Quickcheck.Generator.t ->
                              'a t Core_kernel__.Quickcheck.Generator.t
                            val invariants : 'a t -> bool
                            val is_empty : 'a t -> bool
                            val length : 'a t -> int
                            val add : 'a t -> key:edge -> data:'-> 'a t
                            val add_multi :
                              'a list t -> key:edge -> data:'-> 'a list t
                            val remove_multi : 'a list t -> edge -> 'a list t
                            val change :
                              'a t ->
                              edge -> f:('a option -> 'a option) -> 'a t
                            val update :
                              'a t -> edge -> f:('a option -> 'a) -> 'a t
                            val find : 'a t -> edge -> 'a option
                            val find_exn : 'a t -> edge -> 'a
                            val remove : 'a t -> edge -> 'a t
                            val mem : 'a t -> edge -> bool
                            val iter_keys : 'a t -> f:(edge -> unit) -> unit
                            val iter : 'a t -> f:('-> unit) -> unit
                            val iteri :
                              'a t -> f:(key:edge -> data:'-> unit) -> unit
                            val iter2 :
                              'a t ->
                              'b t ->
                              f:(key:edge ->
                                 data:[ `Both of 'a * 'b
                                      | `Left of 'a
                                      | `Right of 'b ] ->
                                 unit) ->
                              unit
                            val map : 'a t -> f:('-> 'b) -> 'b t
                            val mapi :
                              'a t -> f:(key:edge -> data:'-> 'b) -> 'b t
                            val fold :
                              'a t ->
                              init:'->
                              f:(key:edge -> data:'-> '-> 'b) -> 'b
                            val fold_right :
                              'a t ->
                              init:'->
                              f:(key:edge -> data:'-> '-> 'b) -> 'b
                            val fold2 :
                              'a t ->
                              'b t ->
                              init:'->
                              f:(key:edge ->
                                 data:[ `Both of 'a * 'b
                                      | `Left of 'a
                                      | `Right of 'b ] ->
                                 '-> 'c) ->
                              'c
                            val filter_keys :
                              'a t -> f:(edge -> bool) -> 'a t
                            val filter : 'a t -> f:('-> bool) -> 'a t
                            val filteri :
                              'a t -> f:(key:edge -> data:'-> bool) -> 'a t
                            val filter_map :
                              'a t -> f:('-> 'b option) -> 'b t
                            val filter_mapi :
                              'a t ->
                              f:(key:edge -> data:'-> 'b option) -> 'b t
                            val partition_mapi :
                              'a t ->
                              f:(key:edge ->
                                 data:'-> [ `Fst of '| `Snd of 'c ]) ->
                              'b t * 'c t
                            val partition_map :
                              'a t ->
                              f:('-> [ `Fst of '| `Snd of 'c ]) ->
                              'b t * 'c t
                            val partitioni_tf :
                              'a t ->
                              f:(key:edge -> data:'-> bool) -> 'a t * 'a t
                            val partition_tf :
                              'a t -> f:('-> bool) -> 'a t * 'a t
                            val compare_direct :
                              ('-> '-> int) -> 'a t -> 'a t -> int
                            val equal :
                              ('-> '-> bool) -> 'a t -> 'a t -> bool
                            val keys : 'a t -> edge list
                            val data : 'a t -> 'a list
                            val to_alist :
                              ?key_order:[ `Decreasing | `Increasing ] ->
                              'a t -> (edge * 'a) list
                            val validate :
                              name:(edge -> string) ->
                              'Base__.Validate.check ->
                              'a t Base__.Validate.check
                            val merge :
                              'a t ->
                              'b t ->
                              f:(key:edge ->
                                 [ `Both of 'a * 'b
                                 | `Left of 'a
                                 | `Right of 'b ] -> 'c option) ->
                              'c t
                            val symmetric_diff :
                              'a t ->
                              'a t ->
                              data_equal:('-> '-> bool) ->
                              (edge, 'a)
                              Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                              Base__.Sequence.t
                            val min_elt : 'a t -> (edge * 'a) option
                            val min_elt_exn : 'a t -> edge * 'a
                            val max_elt : 'a t -> (edge * 'a) option
                            val max_elt_exn : 'a t -> edge * 'a
                            val for_all : 'a t -> f:('-> bool) -> bool
                            val for_alli :
                              'a t -> f:(key:edge -> data:'-> bool) -> bool
                            val exists : 'a t -> f:('-> bool) -> bool
                            val existsi :
                              'a t -> f:(key:edge -> data:'-> bool) -> bool
                            val count : 'a t -> f:('-> bool) -> int
                            val counti :
                              'a t -> f:(key:edge -> data:'-> bool) -> int
                            val split :
                              'a t ->
                              edge -> 'a t * (edge * 'a) option * 'a t
                            val append :
                              lower_part:'a t ->
                              upper_part:'a t ->
                              [ `Ok of 'a t | `Overlapping_key_ranges ]
                            val subrange :
                              'a t ->
                              lower_bound:edge Base__.Maybe_bound.t ->
                              upper_bound:edge Base__.Maybe_bound.t -> 'a t
                            val fold_range_inclusive :
                              'a t ->
                              min:edge ->
                              max:edge ->
                              init:'->
                              f:(key:edge -> data:'-> '-> 'b) -> 'b
                            val range_to_alist :
                              'a t ->
                              min:edge -> max:edge -> (edge * 'a) list
                            val closest_key :
                              'a t ->
                              [ `Greater_or_equal_to
                              | `Greater_than
                              | `Less_or_equal_to
                              | `Less_than ] -> edge -> (edge * 'a) option
                            val nth : 'a t -> int -> (edge * 'a) option
                            val nth_exn : 'a t -> int -> edge * 'a
                            val rank : 'a t -> edge -> int option
                            val to_tree : 'a t -> 'a t
                            val to_sequence :
                              ?order:[ `Decreasing_key | `Increasing_key ] ->
                              ?keys_greater_or_equal_to:edge ->
                              ?keys_less_or_equal_to:edge ->
                              'a t -> (edge * 'a) Base__.Sequence.t
                            val obs :
                              edge Core_kernel__.Quickcheck.Observer.t ->
                              'Core_kernel__.Quickcheck.Observer.t ->
                              'v t Core_kernel__.Quickcheck.Observer.t
                            val shrinker :
                              edge Core_kernel__.Quickcheck.Shrinker.t ->
                              'Core_kernel__.Quickcheck.Shrinker.t ->
                              'v t Core_kernel__.Quickcheck.Shrinker.t
                            module Provide_of_sexp :
                              functor
                                (K : sig
                                       val t_of_sexp : Sexplib.Sexp.t -> edge
                                     end->
                                sig
                                  val t_of_sexp :
                                    (Sexplib.Sexp.t -> 'v_x__017_) ->
                                    Sexplib.Sexp.t -> 'v_x__017_ t
                                end
                            val t_of_sexp :
                              (Base__.Sexplib.Sexp.t -> 'a) ->
                              Base__.Sexplib.Sexp.t -> 'a t
                            val sexp_of_t :
                              ('-> Base__.Sexplib.Sexp.t) ->
                              'a t -> Base__.Sexplib.Sexp.t
                          end
                        type 'a t =
                            (edge, 'a, comparator_witness)
                            Core_kernel__.Core_map_intf.Map.t
                        val compare :
                          ('-> '-> Core_kernel__.Import.int) ->
                          'a t -> 'a t -> Core_kernel__.Import.int
                        val empty : 'a t
                        val singleton : edge -> '-> 'a t
                        val of_alist :
                          (edge * 'a) list ->
                          [ `Duplicate_key of edge | `Ok of 'a t ]
                        val of_alist_or_error :
                          (edge * 'a) list -> 'a t Base__.Or_error.t
                        val of_alist_exn : (edge * 'a) list -> 'a t
                        val of_alist_multi : (edge * 'a) list -> 'a list t
                        val of_alist_fold :
                          (edge * 'a) list ->
                          init:'-> f:('-> '-> 'b) -> 'b t
                        val of_alist_reduce :
                          (edge * 'a) list -> f:('-> '-> 'a) -> 'a t
                        val of_sorted_array :
                          (edge * 'a) array -> 'a t Base__.Or_error.t
                        val of_sorted_array_unchecked :
                          (edge * 'a) array -> 'a t
                        val of_increasing_iterator_unchecked :
                          len:int -> f:(int -> edge * 'a) -> 'a t
                        val of_iteri :
                          iteri:(f:(key:edge -> data:'-> unit) -> unit) ->
                          [ `Duplicate_key of edge | `Ok of 'v t ]
                        val of_tree : 'Tree.t -> 'a t
                        val of_hashtbl_exn :
                          (edge, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                        val gen :
                          edge Core_kernel__.Quickcheck.Generator.t ->
                          'Core_kernel__.Quickcheck.Generator.t ->
                          'a t Core_kernel__.Quickcheck.Generator.t
                        val invariants : 'a t -> bool
                        val is_empty : 'a t -> bool
                        val length : 'a t -> int
                        val add : 'a t -> key:edge -> data:'-> 'a t
                        val add_multi :
                          'a list t -> key:edge -> data:'-> 'a list t
                        val remove_multi : 'a list t -> edge -> 'a list t
                        val change :
                          'a t -> edge -> f:('a option -> 'a option) -> 'a t
                        val update :
                          'a t -> edge -> f:('a option -> 'a) -> 'a t
                        val find : 'a t -> edge -> 'a option
                        val find_exn : 'a t -> edge -> 'a
                        val remove : 'a t -> edge -> 'a t
                        val mem : 'a t -> edge -> bool
                        val iter_keys : 'a t -> f:(edge -> unit) -> unit
                        val iter : 'a t -> f:('-> unit) -> unit
                        val iteri :
                          'a t -> f:(key:edge -> data:'-> unit) -> unit
                        val iter2 :
                          'a t ->
                          'b t ->
                          f:(key:edge ->
                             data:[ `Both of 'a * 'b
                                  | `Left of 'a
                                  | `Right of 'b ] ->
                             unit) ->
                          unit
                        val map : 'a t -> f:('-> 'b) -> 'b t
                        val mapi :
                          'a t -> f:(key:edge -> data:'-> 'b) -> 'b t
                        val fold :
                          'a t ->
                          init:'->
                          f:(key:edge -> data:'-> '-> 'b) -> 'b
                        val fold_right :
                          'a t ->
                          init:'->
                          f:(key:edge -> data:'-> '-> 'b) -> 'b
                        val fold2 :
                          'a t ->
                          'b t ->
                          init:'->
                          f:(key:edge ->
                             data:[ `Both of 'a * 'b
                                  | `Left of 'a
                                  | `Right of 'b ] ->
                             '-> 'c) ->
                          'c
                        val filter_keys : 'a t -> f:(edge -> bool) -> 'a t
                        val filter : 'a t -> f:('-> bool) -> 'a t
                        val filteri :
                          'a t -> f:(key:edge -> data:'-> bool) -> 'a t
                        val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                        val filter_mapi :
                          'a t ->
                          f:(key:edge -> data:'-> 'b option) -> 'b t
                        val partition_mapi :
                          'a t ->
                          f:(key:edge ->
                             data:'-> [ `Fst of '| `Snd of 'c ]) ->
                          'b t * 'c t
                        val partition_map :
                          'a t ->
                          f:('-> [ `Fst of '| `Snd of 'c ]) ->
                          'b t * 'c t
                        val partitioni_tf :
                          'a t ->
                          f:(key:edge -> data:'-> bool) -> 'a t * 'a t
                        val partition_tf :
                          'a t -> f:('-> bool) -> 'a t * 'a t
                        val compare_direct :
                          ('-> '-> int) -> 'a t -> 'a t -> int
                        val equal :
                          ('-> '-> bool) -> 'a t -> 'a t -> bool
                        val keys : 'a t -> edge list
                        val data : 'a t -> 'a list
                        val to_alist :
                          ?key_order:[ `Decreasing | `Increasing ] ->
                          'a t -> (edge * 'a) list
                        val validate :
                          name:(edge -> string) ->
                          'Base__.Validate.check ->
                          'a t Base__.Validate.check
                        val merge :
                          'a t ->
                          'b t ->
                          f:(key:edge ->
                             [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                             'c option) ->
                          'c t
                        val symmetric_diff :
                          'a t ->
                          'a t ->
                          data_equal:('-> '-> bool) ->
                          (edge, 'a)
                          Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                          Base__.Sequence.t
                        val min_elt : 'a t -> (edge * 'a) option
                        val min_elt_exn : 'a t -> edge * 'a
                        val max_elt : 'a t -> (edge * 'a) option
                        val max_elt_exn : 'a t -> edge * 'a
                        val for_all : 'a t -> f:('-> bool) -> bool
                        val for_alli :
                          'a t -> f:(key:edge -> data:'-> bool) -> bool
                        val exists : 'a t -> f:('-> bool) -> bool
                        val existsi :
                          'a t -> f:(key:edge -> data:'-> bool) -> bool
                        val count : 'a t -> f:('-> bool) -> int
                        val counti :
                          'a t -> f:(key:edge -> data:'-> bool) -> int
                        val split :
                          'a t -> edge -> 'a t * (edge * 'a) option * 'a t
                        val append :
                          lower_part:'a t ->
                          upper_part:'a t ->
                          [ `Ok of 'a t | `Overlapping_key_ranges ]
                        val subrange :
                          'a t ->
                          lower_bound:edge Base__.Maybe_bound.t ->
                          upper_bound:edge Base__.Maybe_bound.t -> 'a t
                        val fold_range_inclusive :
                          'a t ->
                          min:edge ->
                          max:edge ->
                          init:'->
                          f:(key:edge -> data:'-> '-> 'b) -> 'b
                        val range_to_alist :
                          'a t -> min:edge -> max:edge -> (edge * 'a) list
                        val closest_key :
                          'a t ->
                          [ `Greater_or_equal_to
                          | `Greater_than
                          | `Less_or_equal_to
                          | `Less_than ] -> edge -> (edge * 'a) option
                        val nth : 'a t -> int -> (edge * 'a) option
                        val nth_exn : 'a t -> int -> edge * 'a
                        val rank : 'a t -> edge -> int option
                        val to_tree : 'a t -> 'Tree.t
                        val to_sequence :
                          ?order:[ `Decreasing_key | `Increasing_key ] ->
                          ?keys_greater_or_equal_to:edge ->
                          ?keys_less_or_equal_to:edge ->
                          'a t -> (edge * 'a) Base__.Sequence.t
                        val obs :
                          edge Core_kernel__.Quickcheck.Observer.t ->
                          'Core_kernel__.Quickcheck.Observer.t ->
                          'v t Core_kernel__.Quickcheck.Observer.t
                        val shrinker :
                          edge Core_kernel__.Quickcheck.Shrinker.t ->
                          'Core_kernel__.Quickcheck.Shrinker.t ->
                          'v t Core_kernel__.Quickcheck.Shrinker.t
                        module Provide_of_sexp :
                          functor
                            (Key : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> edge
                                   end->
                            sig
                              val t_of_sexp :
                                (Sexplib.Sexp.t -> 'v_x__018_) ->
                                Sexplib.Sexp.t -> 'v_x__018_ t
                            end
                        module Provide_bin_io :
                          functor
                            (Key : sig
                                     val bin_t : edge Bin_prot.Type_class.t
                                     val bin_read_t :
                                       edge Bin_prot.Read.reader
                                     val __bin_read_t__ :
                                       (Core_kernel__.Import.int -> edge)
                                       Bin_prot.Read.reader
                                     val bin_reader_t :
                                       edge Bin_prot.Type_class.reader
                                     val bin_size_t :
                                       edge Bin_prot.Size.sizer
                                     val bin_write_t :
                                       edge Bin_prot.Write.writer
                                     val bin_writer_t :
                                       edge Bin_prot.Type_class.writer
                                     val bin_shape_t : Bin_prot.Shape.t
                                   end->
                            sig
                              val bin_shape_t :
                                Bin_prot.Shape.t -> Bin_prot.Shape.t
                              val bin_size_t :
                                ('a, 'a t) Bin_prot.Size.sizer1
                              val bin_write_t :
                                ('a, 'a t) Bin_prot.Write.writer1
                              val bin_read_t :
                                ('a, 'a t) Bin_prot.Read.reader1
                              val __bin_read_t__ :
                                ('a, int -> 'a t) Bin_prot.Read.reader1
                              val bin_writer_t :
                                ('a, 'a t) Bin_prot.Type_class.S1.writer
                              val bin_reader_t :
                                ('a, 'a t) Bin_prot.Type_class.S1.reader
                              val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                            end
                        module Provide_hash :
                          functor
                            (Key : sig
                                     val hash_fold_t :
                                       Base__.Hash.state ->
                                       edge -> Base__.Hash.state
                                   end->
                            sig
                              val hash_fold_t :
                                (Ppx_hash_lib.Std.Hash.state ->
                                 '-> Ppx_hash_lib.Std.Hash.state) ->
                                Ppx_hash_lib.Std.Hash.state ->
                                'a t -> Ppx_hash_lib.Std.Hash.state
                            end
                        val t_of_sexp :
                          (Base__.Sexplib.Sexp.t -> 'a) ->
                          Base__.Sexplib.Sexp.t -> 'a t
                        val sexp_of_t :
                          ('-> Base__.Sexplib.Sexp.t) ->
                          'a t -> Base__.Sexplib.Sexp.t
                      end
                    module Set :
                      sig
                        module Elt :
                          sig
                            type t = edge
                            val t_of_sexp : Sexplib.Sexp.t -> t
                            val sexp_of_t : t -> Sexplib.Sexp.t
                            type comparator_witness =
                                Map.Key.comparator_witness
                            val comparator :
                              (t, comparator_witness)
                              Core_kernel__.Comparator.comparator
                          end
                        module Tree :
                          sig
                            type t =
                                (edge, comparator_witness)
                                Core_kernel__.Core_set_intf.Tree.t
                            val compare : t -> t -> Core_kernel__.Import.int
                            val length : t -> int
                            val is_empty : t -> bool
                            val iter : t -> f:(edge -> unit) -> unit
                            val fold :
                              t ->
                              init:'accum ->
                              f:('accum -> edge -> 'accum) -> 'accum
                            val fold_result :
                              t ->
                              init:'accum ->
                              f:('accum ->
                                 edge -> ('accum, 'e) Base__.Result.t) ->
                              ('accum, 'e) Base__.Result.t
                            val exists : t -> f:(edge -> bool) -> bool
                            val for_all : t -> f:(edge -> bool) -> bool
                            val count : t -> f:(edge -> bool) -> int
                            val sum :
                              (module Base__.Commutative_group.S with type t = 'sum) ->
                              t -> f:(edge -> 'sum) -> 'sum
                            val find : t -> f:(edge -> bool) -> edge option
                            val find_map :
                              t -> f:(edge -> 'a option) -> 'a option
                            val to_list : t -> edge list
                            val to_array : t -> edge array
                            val invariants : t -> bool
                            val mem : t -> edge -> bool
                            val add : t -> edge -> t
                            val remove : t -> edge -> t
                            val union : t -> t -> t
                            val inter : t -> t -> t
                            val diff : t -> t -> t
                            val symmetric_diff :
                              t ->
                              t ->
                              (edge, edge) Base__.Either.t Base__.Sequence.t
                            val compare_direct : t -> t -> int
                            val equal : t -> t -> bool
                            val is_subset : t -> of_:t -> bool
                            val subset : t -> t -> bool
                            val fold_until :
                              t ->
                              init:'->
                              f:('->
                                 edge ->
                                 ('b, 'stop)
                                 Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                              ('b, 'stop)
                              Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                            val fold_right :
                              t -> init:'-> f:(edge -> '-> 'b) -> 'b
                            val iter2 :
                              t ->
                              t ->
                              f:([ `Both of edge * edge
                                 | `Left of edge
                                 | `Right of edge ] -> unit) ->
                              unit
                            val filter : t -> f:(edge -> bool) -> t
                            val partition_tf : t -> f:(edge -> bool) -> t * t
                            val elements : t -> edge list
                            val min_elt : t -> edge option
                            val min_elt_exn : t -> edge
                            val max_elt : t -> edge option
                            val max_elt_exn : t -> edge
                            val choose : t -> edge option
                            val choose_exn : t -> edge
                            val split : t -> edge -> t * edge option * t
                            val group_by :
                              t -> equiv:(edge -> edge -> bool) -> t list
                            val find_exn : t -> f:(edge -> bool) -> edge
                            val find_index : t -> int -> edge option
                            val nth : t -> int -> edge option
                            val remove_index : t -> int -> t
                            val to_tree : t -> t
                            val to_sequence :
                              ?order:[ `Decreasing | `Increasing ] ->
                              ?greater_or_equal_to:edge ->
                              ?less_or_equal_to:edge ->
                              t -> edge Base__.Sequence.t
                            val merge_to_sequence :
                              ?order:[ `Decreasing | `Increasing ] ->
                              ?greater_or_equal_to:edge ->
                              ?less_or_equal_to:edge ->
                              t ->
                              t ->
                              (edge, edge)
                              Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                              Base__.Sequence.t
                            val to_map :
                              t ->
                              f:(edge -> 'data) ->
                              (edge, 'data, comparator_witness)
                              Core_kernel__.Core_set_intf.Map.t
                            val obs :
                              edge Core_kernel__.Quickcheck.Observer.t ->
                              t Core_kernel__.Quickcheck.Observer.t
                            val shrinker :
                              edge Core_kernel__.Quickcheck.Shrinker.t ->
                              t Core_kernel__.Quickcheck.Shrinker.t
                            val empty : t
                            val singleton : edge -> t
                            val union_list : t list -> t
                            val of_list : edge list -> t
                            val of_array : edge array -> t
                            val of_sorted_array :
                              edge array -> t Base__.Or_error.t
                            val of_sorted_array_unchecked : edge array -> t
                            val of_increasing_iterator_unchecked :
                              len:int -> f:(int -> edge) -> t
                            val stable_dedup_list : edge list -> edge list
                            val map :
                              ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                              f:('-> edge) -> t
                            val filter_map :
                              ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                              f:('-> edge option) -> t
                            val of_tree : t -> t
                            val of_hash_set :
                              edge Core_kernel__.Hash_set.t -> t
                            val of_hashtbl_keys :
                              (edge, 'a) Core_kernel__.Core_hashtbl.t -> t
                            val of_map_keys :
                              (edge, 'a, comparator_witness)
                              Core_kernel__.Core_set_intf.Map.t -> t
                            val gen :
                              edge Core_kernel__.Quickcheck.Generator.t ->
                              t Core_kernel__.Quickcheck.Generator.t
                            module Provide_of_sexp :
                              functor
                                (Elt : sig
                                         val t_of_sexp :
                                           Sexplib.Sexp.t -> edge
                                       end->
                                sig val t_of_sexp : Sexplib.Sexp.t -> t end
                            val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                            val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                          end
                        type t = (edge, comparator_witness) Base.Set.t
                        val compare : t -> t -> Core_kernel__.Import.int
                        val length : t -> int
                        val is_empty : t -> bool
                        val iter : t -> f:(edge -> unit) -> unit
                        val fold :
                          t ->
                          init:'accum ->
                          f:('accum -> edge -> 'accum) -> 'accum
                        val fold_result :
                          t ->
                          init:'accum ->
                          f:('accum -> edge -> ('accum, 'e) Base__.Result.t) ->
                          ('accum, 'e) Base__.Result.t
                        val exists : t -> f:(edge -> bool) -> bool
                        val for_all : t -> f:(edge -> bool) -> bool
                        val count : t -> f:(edge -> bool) -> int
                        val sum :
                          (module Base__.Commutative_group.S with type t = 'sum) ->
                          t -> f:(edge -> 'sum) -> 'sum
                        val find : t -> f:(edge -> bool) -> edge option
                        val find_map :
                          t -> f:(edge -> 'a option) -> 'a option
                        val to_list : t -> edge list
                        val to_array : t -> edge array
                        val invariants : t -> bool
                        val mem : t -> edge -> bool
                        val add : t -> edge -> t
                        val remove : t -> edge -> t
                        val union : t -> t -> t
                        val inter : t -> t -> t
                        val diff : t -> t -> t
                        val symmetric_diff :
                          t ->
                          t -> (edge, edge) Base__.Either.t Base__.Sequence.t
                        val compare_direct : t -> t -> int
                        val equal : t -> t -> bool
                        val is_subset : t -> of_:t -> bool
                        val subset : t -> t -> bool
                        val fold_until :
                          t ->
                          init:'->
                          f:('->
                             edge ->
                             ('b, 'stop)
                             Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                          ('b, 'stop)
                          Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                        val fold_right :
                          t -> init:'-> f:(edge -> '-> 'b) -> 'b
                        val iter2 :
                          t ->
                          t ->
                          f:([ `Both of edge * edge
                             | `Left of edge
                             | `Right of edge ] -> unit) ->
                          unit
                        val filter : t -> f:(edge -> bool) -> t
                        val partition_tf : t -> f:(edge -> bool) -> t * t
                        val elements : t -> edge list
                        val min_elt : t -> edge option
                        val min_elt_exn : t -> edge
                        val max_elt : t -> edge option
                        val max_elt_exn : t -> edge
                        val choose : t -> edge option
                        val choose_exn : t -> edge
                        val split : t -> edge -> t * edge option * t
                        val group_by :
                          t -> equiv:(edge -> edge -> bool) -> t list
                        val find_exn : t -> f:(edge -> bool) -> edge
                        val find_index : t -> int -> edge option
                        val nth : t -> int -> edge option
                        val remove_index : t -> int -> t
                        val to_tree : t -> Tree.t
                        val to_sequence :
                          ?order:[ `Decreasing | `Increasing ] ->
                          ?greater_or_equal_to:edge ->
                          ?less_or_equal_to:edge ->
                          t -> edge Base__.Sequence.t
                        val merge_to_sequence :
                          ?order:[ `Decreasing | `Increasing ] ->
                          ?greater_or_equal_to:edge ->
                          ?less_or_equal_to:edge ->
                          t ->
                          t ->
                          (edge, edge)
                          Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                          Base__.Sequence.t
                        val to_map :
                          t ->
                          f:(edge -> 'data) ->
                          (edge, 'data, comparator_witness)
                          Core_kernel__.Core_set_intf.Map.t
                        val obs :
                          edge Core_kernel__.Quickcheck.Observer.t ->
                          t Core_kernel__.Quickcheck.Observer.t
                        val shrinker :
                          edge Core_kernel__.Quickcheck.Shrinker.t ->
                          t Core_kernel__.Quickcheck.Shrinker.t
                        val empty : t
                        val singleton : edge -> t
                        val union_list : t list -> t
                        val of_list : edge list -> t
                        val of_array : edge array -> t
                        val of_sorted_array :
                          edge array -> t Base__.Or_error.t
                        val of_sorted_array_unchecked : edge array -> t
                        val of_increasing_iterator_unchecked :
                          len:int -> f:(int -> edge) -> t
                        val stable_dedup_list : edge list -> edge list
                        val map : ('a, 'b) Base.Set.t -> f:('-> edge) -> t
                        val filter_map :
                          ('a, 'b) Base.Set.t -> f:('-> edge option) -> t
                        val of_tree : Tree.t -> t
                        val of_hash_set : edge Core_kernel__.Hash_set.t -> t
                        val of_hashtbl_keys :
                          (edge, 'a) Core_kernel__.Core_hashtbl.t -> t
                        val of_map_keys :
                          (edge, 'a, comparator_witness)
                          Core_kernel__.Core_set_intf.Map.t -> t
                        val gen :
                          edge Core_kernel__.Quickcheck.Generator.t ->
                          t Core_kernel__.Quickcheck.Generator.t
                        module Provide_of_sexp :
                          functor
                            (Elt : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> edge
                                   end->
                            sig val t_of_sexp : Sexplib.Sexp.t -> t end
                        module Provide_bin_io :
                          functor
                            (Elt : sig
                                     val bin_t : edge Bin_prot.Type_class.t
                                     val bin_read_t :
                                       edge Bin_prot.Read.reader
                                     val __bin_read_t__ :
                                       (Core_kernel__.Import.int -> edge)
                                       Bin_prot.Read.reader
                                     val bin_reader_t :
                                       edge Bin_prot.Type_class.reader
                                     val bin_size_t :
                                       edge Bin_prot.Size.sizer
                                     val bin_write_t :
                                       edge Bin_prot.Write.writer
                                     val bin_writer_t :
                                       edge Bin_prot.Type_class.writer
                                     val bin_shape_t : Bin_prot.Shape.t
                                   end->
                            sig
                              val bin_size_t : t Bin_prot.Size.sizer
                              val bin_write_t : t Bin_prot.Write.writer
                              val bin_read_t : t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                (int -> t) Bin_prot.Read.reader
                              val bin_shape_t : Bin_prot.Shape.t
                              val bin_writer_t : t Bin_prot.Type_class.writer
                              val bin_reader_t : t Bin_prot.Type_class.reader
                              val bin_t : t Bin_prot.Type_class.t
                            end
                        module Provide_hash :
                          functor
                            (Elt : sig
                                     val hash_fold_t :
                                       Base__.Hash.state ->
                                       edge -> Base__.Hash.state
                                   end->
                            sig
                              val hash_fold_t :
                                Ppx_hash_lib.Std.Hash.state ->
                                t -> Ppx_hash_lib.Std.Hash.state
                              val hash :
                                t -> Ppx_hash_lib.Std.Hash.hash_value
                            end
                        val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                        val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                      end
                    val hash : t -> Core_kernel__.Import.int
                    val compare : t -> t -> Core_kernel__.Import.int
                    val hashable :
                      t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
                    module Table :
                      sig
                        type key = t
                        type ('a, 'b) hashtbl = ('a, 'b) Node.Table.hashtbl
                        type 'b t = (key, 'b) hashtbl
                        val sexp_of_t :
                          ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                        type ('a, 'b) t_ = 'b t
                        type 'a key_ = key
                        val hashable :
                          key Core_kernel__.Core_hashtbl_intf.Hashable.t
                        val invariant :
                          'Base__.Invariant_intf.inv ->
                          'a t Base__.Invariant_intf.inv
                        val create :
                          (key, 'b, unit -> 'b t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist :
                          (key, 'b,
                           (key * 'b) list ->
                           [ `Duplicate_key of key | `Ok of 'b t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_report_all_dups :
                          (key, 'b,
                           (key * 'b) list ->
                           [ `Duplicate_keys of key list | `Ok of 'b t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_or_error :
                          (key, 'b,
                           (key * 'b) list -> 'b t Base__.Or_error.t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_exn :
                          (key, 'b, (key * 'b) list -> 'b t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val of_alist_multi :
                          (key, 'b list, (key * 'b) list -> 'b list t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_mapped :
                          (key, 'b,
                           get_key:('-> key) ->
                           get_data:('-> 'b) ->
                           'r list ->
                           [ `Duplicate_keys of key list | `Ok of 'b t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_with_key :
                          (key, 'r,
                           get_key:('-> key) ->
                           'r list ->
                           [ `Duplicate_keys of key list | `Ok of 'r t ])
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_with_key_or_error :
                          (key, 'r,
                           get_key:('-> key) ->
                           'r list -> 'r t Base__.Or_error.t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val create_with_key_exn :
                          (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val group :
                          (key, 'b,
                           get_key:('-> key) ->
                           get_data:('-> 'b) ->
                           combine:('-> '-> 'b) -> 'r list -> 'b t)
                          Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                        val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                        val clear : 'a t -> unit
                        val copy : 'b t -> 'b t
                        val fold :
                          'b t ->
                          init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                        val iter_keys : 'a t -> f:(key -> unit) -> unit
                        val iter : 'b t -> f:('-> unit) -> unit
                        val iteri :
                          'b t -> f:(key:key -> data:'-> unit) -> unit
                        val iter_vals : 'b t -> f:('-> unit) -> unit
                        val existsi :
                          'b t -> f:(key:key -> data:'-> bool) -> bool
                        val exists : 'b t -> f:('-> bool) -> bool
                        val for_alli :
                          'b t -> f:(key:key -> data:'-> bool) -> bool
                        val for_all : 'b t -> f:('-> bool) -> bool
                        val counti :
                          'b t -> f:(key:key -> data:'-> bool) -> int
                        val count : 'b t -> f:('-> bool) -> int
                        val length : 'a t -> int
                        val is_empty : 'a t -> bool
                        val mem : 'a t -> key -> bool
                        val remove : 'a t -> key -> unit
                        val replace : 'b t -> key:key -> data:'-> unit
                        val set : 'b t -> key:key -> data:'-> unit
                        val add :
                          'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                        val add_or_error :
                          'b t ->
                          key:key -> data:'-> unit Base__.Or_error.t
                        val add_exn : 'b t -> key:key -> data:'-> unit
                        val change :
                          'b t -> key -> f:('b option -> 'b option) -> unit
                        val update :
                          'b t -> key -> f:('b option -> 'b) -> unit
                        val add_multi :
                          'b list t -> key:key -> data:'-> unit
                        val remove_multi : 'a list t -> key -> unit
                        val map : 'b t -> f:('-> 'c) -> 'c t
                        val mapi :
                          'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                        val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                        val filter_mapi :
                          'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                        val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                        val filter : 'b t -> f:('-> bool) -> 'b t
                        val filteri :
                          'b t -> f:(key:key -> data:'-> bool) -> 'b t
                        val partition_map :
                          'b t ->
                          f:('-> [ `Fst of '| `Snd of 'd ]) ->
                          'c t * 'd t
                        val partition_mapi :
                          'b t ->
                          f:(key:key ->
                             data:'-> [ `Fst of '| `Snd of 'd ]) ->
                          'c t * 'd t
                        val partition_tf :
                          'b t -> f:('-> bool) -> 'b t * 'b t
                        val partitioni_tf :
                          'b t ->
                          f:(key:key -> data:'-> bool) -> 'b t * 'b t
                        val find_or_add :
                          'b t -> key -> default:(unit -> 'b) -> 'b
                        val find : 'b t -> key -> 'b option
                        val find_exn : 'b t -> key -> 'b
                        val find_and_call :
                          'b t ->
                          key ->
                          if_found:('-> 'c) ->
                          if_not_found:(key -> 'c) -> 'c
                        val find_and_remove : 'b t -> key -> 'b option
                        val merge :
                          'a t ->
                          'b t ->
                          f:(key:key ->
                             [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                             'c option) ->
                          'c t
                        type 'a merge_into_action = Remove | Set_to of 'a
                        val merge_into :
                          src:'a t ->
                          dst:'b t ->
                          f:(key:key ->
                             '-> 'b option -> 'b merge_into_action) ->
                          unit
                        val keys : 'a t -> key list
                        val data : 'b t -> 'b list
                        val filter_keys_inplace :
                          'a t -> f:(key -> bool) -> unit
                        val filter_inplace : 'b t -> f:('-> bool) -> unit
                        val filteri_inplace :
                          'b t -> f:(key:key -> data:'-> bool) -> unit
                        val map_inplace : 'b t -> f:('-> 'b) -> unit
                        val mapi_inplace :
                          'b t -> f:(key:key -> data:'-> 'b) -> unit
                        val filter_map_inplace :
                          'b t -> f:('-> 'b option) -> unit
                        val filter_mapi_inplace :
                          'b t -> f:(key:key -> data:'-> 'b option) -> unit
                        val replace_all : 'b t -> f:('-> 'b) -> unit
                        val replace_alli :
                          'b t -> f:(key:key -> data:'-> 'b) -> unit
                        val filter_replace_all :
                          'b t -> f:('-> 'b option) -> unit
                        val filter_replace_alli :
                          'b t -> f:(key:key -> data:'-> 'b option) -> unit
                        val equal :
                          'b t -> 'b t -> ('-> '-> bool) -> bool
                        val similar :
                          'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                        val to_alist : 'b t -> (key * 'b) list
                        val validate :
                          name:(key -> string) ->
                          'Base__.Validate.check ->
                          'b t Base__.Validate.check
                        val incr :
                          ?by:int ->
                          ?remove_if_zero:bool -> int t -> key -> unit
                        val decr :
                          ?by:int ->
                          ?remove_if_zero:bool -> int t -> key -> unit
                        module Provide_of_sexp :
                          functor
                            (Key : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> key
                                   end->
                            sig
                              val t_of_sexp :
                                (Sexplib.Sexp.t -> 'v_x__001_) ->
                                Sexplib.Sexp.t -> 'v_x__001_ t
                            end
                        module Provide_bin_io :
                          functor
                            (Key : sig
                                     val bin_t : key Bin_prot.Type_class.t
                                     val bin_read_t :
                                       key Bin_prot.Read.reader
                                     val __bin_read_t__ :
                                       (Core_kernel__.Import.int -> key)
                                       Bin_prot.Read.reader
                                     val bin_reader_t :
                                       key Bin_prot.Type_class.reader
                                     val bin_size_t : key Bin_prot.Size.sizer
                                     val bin_write_t :
                                       key Bin_prot.Write.writer
                                     val bin_writer_t :
                                       key Bin_prot.Type_class.writer
                                     val bin_shape_t : Bin_prot.Shape.t
                                   end->
                            sig
                              val bin_t :
                                'Bin_prot.Type_class.t ->
                                'a t Bin_prot.Type_class.t
                              val bin_read_t :
                                'Bin_prot.Read.reader ->
                                'a t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                'Bin_prot.Read.reader ->
                                (Core_kernel__.Import.int -> 'a t)
                                Bin_prot.Read.reader
                              val bin_reader_t :
                                'Bin_prot.Type_class.reader ->
                                'a t Bin_prot.Type_class.reader
                              val bin_size_t :
                                'Bin_prot.Size.sizer ->
                                'a t Bin_prot.Size.sizer
                              val bin_write_t :
                                'Bin_prot.Write.writer ->
                                'a t Bin_prot.Write.writer
                              val bin_writer_t :
                                'Bin_prot.Type_class.writer ->
                                'a t Bin_prot.Type_class.writer
                              val bin_shape_t :
                                Bin_prot.Shape.t -> Bin_prot.Shape.t
                            end
                        val t_of_sexp :
                          (Sexplib.Sexp.t -> 'v_x__002_) ->
                          Sexplib.Sexp.t -> 'v_x__002_ t
                      end
                    module Hash_set :
                      sig
                        type elt = t
                        type t = elt Core_kernel__.Hash_set.t
                        val sexp_of_t : t -> Sexplib.Sexp.t
                        type 'a t_ = t
                        type 'a elt_ = elt
                        val create :
                          ('a, unit -> t)
                          Core_kernel__.Hash_set_intf.create_options_without_hashable
                        val of_list :
                          ('a, elt list -> t)
                          Core_kernel__.Hash_set_intf.create_options_without_hashable
                        module Provide_of_sexp :
                          functor
                            (X : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> elt
                                 end->
                            sig val t_of_sexp : Sexplib.Sexp.t -> t end
                        module Provide_bin_io :
                          functor
                            (X : sig
                                   val bin_t : elt Bin_prot.Type_class.t
                                   val bin_read_t : elt Bin_prot.Read.reader
                                   val __bin_read_t__ :
                                     (Core_kernel__.Import.int -> elt)
                                     Bin_prot.Read.reader
                                   val bin_reader_t :
                                     elt Bin_prot.Type_class.reader
                                   val bin_size_t : elt Bin_prot.Size.sizer
                                   val bin_write_t :
                                     elt Bin_prot.Write.writer
                                   val bin_writer_t :
                                     elt Bin_prot.Type_class.writer
                                   val bin_shape_t : Bin_prot.Shape.t
                                 end->
                            sig
                              val bin_t : t Bin_prot.Type_class.t
                              val bin_read_t : t Bin_prot.Read.reader
                              val __bin_read_t__ :
                                (Core_kernel__.Import.int -> t)
                                Bin_prot.Read.reader
                              val bin_reader_t : t Bin_prot.Type_class.reader
                              val bin_size_t : t Bin_prot.Size.sizer
                              val bin_write_t : t Bin_prot.Write.writer
                              val bin_writer_t : t Bin_prot.Type_class.writer
                              val bin_shape_t : Bin_prot.Shape.t
                            end
                        val t_of_sexp : Sexplib.Sexp.t -> t
                      end
                    module Hash_queue :
                      sig
                        module Key :
                          sig
                            type t = edge
                            val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                            val compare : t -> t -> int
                            val hash : t -> int
                          end
                        type 'a t
                        val sexp_of_t :
                          ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                        val length : 'a t -> int
                        val is_empty : 'a t -> bool
                        val iter : 'a t -> f:('-> unit) -> unit
                        val fold :
                          'a t ->
                          init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                        val fold_result :
                          'a t ->
                          init:'accum ->
                          f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                          ('accum, 'e) Base__.Result.t
                        val fold_until :
                          'a t ->
                          init:'accum ->
                          f:('accum ->
                             '->
                             ('accum, 'stop)
                             Base.Container_intf.Continue_or_stop.t) ->
                          ('accum, 'stop)
                          Base.Container_intf.Finished_or_stopped_early.t
                        val exists : 'a t -> f:('-> bool) -> bool
                        val for_all : 'a t -> f:('-> bool) -> bool
                        val count : 'a t -> f:('-> bool) -> int
                        val sum :
                          (module Base__.Commutative_group.S with type t = 'sum) ->
                          'a t -> f:('-> 'sum) -> 'sum
                        val find : 'a t -> f:('-> bool) -> 'a option
                        val find_map :
                          'a t -> f:('-> 'b option) -> 'b option
                        val to_list : 'a t -> 'a list
                        val to_array : 'a t -> 'a array
                        val min_elt :
                          'a t -> cmp:('-> '-> int) -> 'a option
                        val max_elt :
                          'a t -> cmp:('-> '-> int) -> 'a option
                        val invariant : 'a t -> Core_kernel__.Import.unit
                        val create :
                          ?growth_allowed:Core_kernel__.Import.bool ->
                          ?size:Core_kernel__.Import.int ->
                          Core_kernel__.Import.unit -> 'a t
                        val clear : 'a t -> Core_kernel__.Import.unit
                        val mem : 'a t -> edge -> Core_kernel__.Import.bool
                        val lookup :
                          'a t -> edge -> 'Core_kernel__.Import.option
                        val lookup_exn : 'a t -> edge -> 'a
                        val enqueue :
                          'a t ->
                          edge -> '-> [ `Key_already_present | `Ok ]
                        val enqueue_exn :
                          'a t -> edge -> '-> Core_kernel__.Import.unit
                        val lookup_and_move_to_back :
                          'a t -> edge -> 'Core_kernel__.Import.option
                        val lookup_and_move_to_back_exn : 'a t -> edge -> 'a
                        val first : 'a t -> 'Core_kernel__.Import.option
                        val first_with_key :
                          'a t -> (edge * 'a) Core_kernel__.Import.option
                        val keys : 'a t -> edge Core_kernel__.Import.list
                        val dequeue : 'a t -> 'Core_kernel__.Import.option
                        val dequeue_exn : 'a t -> 'a
                        val dequeue_with_key :
                          'a t -> (edge * 'a) Core_kernel__.Import.option
                        val dequeue_with_key_exn : 'a t -> edge * 'a
                        val dequeue_all :
                          'a t ->
                          f:('-> Core_kernel__.Import.unit) ->
                          Core_kernel__.Import.unit
                        val remove : 'a t -> edge -> [ `No_such_key | `Ok ]
                        val remove_exn :
                          'a t -> edge -> Core_kernel__.Import.unit
                        val replace :
                          'a t -> edge -> '-> [ `No_such_key | `Ok ]
                        val replace_exn :
                          'a t -> edge -> '-> Core_kernel__.Import.unit
                        val iteri :
                          'a t ->
                          f:(key:edge -> data:'-> Core_kernel__.Import.unit) ->
                          Core_kernel__.Import.unit
                        val foldi :
                          'a t ->
                          init:'->
                          f:('-> key:edge -> data:'-> 'b) -> 'b
                      end
                  end
                val empty : t
                val nodes : t -> node Regular.Std.seq
                val edges : t -> edge Regular.Std.seq
                val is_directed : bool
                val number_of_edges : t -> int
                val number_of_nodes : t -> int
                val ( >= ) : t -> t -> bool
                val ( <= ) : t -> t -> bool
                val ( = ) : t -> t -> bool
                val ( > ) : t -> t -> bool
                val ( < ) : t -> t -> bool
                val ( <> ) : t -> t -> bool
                val equal : t -> t -> bool
                val min : t -> t -> t
                val max : t -> t -> t
                val ascending : t -> t -> int
                val descending : t -> t -> int
                val between : t -> low:t -> high:t -> bool
                val clamp_exn : t -> min:t -> max:t -> t
                val clamp : t -> min:t -> max:t -> t Base__.Or_error.t
                type comparator_witness
                val comparator :
                  (t, comparator_witness) Base__.Comparator.comparator
                val validate_lbound :
                  min:t Base__.Maybe_bound.t -> t Base__.Validate.check
                val validate_ubound :
                  max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                val validate_bound :
                  min:t Base__.Maybe_bound.t ->
                  max:t Base__.Maybe_bound.t -> t Base__.Validate.check
                module Replace_polymorphic_compare :
                  sig
                    val ( >= ) : t -> t -> bool
                    val ( <= ) : t -> t -> bool
                    val ( = ) : t -> t -> bool
                    val ( > ) : t -> t -> bool
                    val ( < ) : t -> t -> bool
                    val ( <> ) : t -> t -> bool
                    val equal : t -> t -> bool
                    val compare : t -> t -> int
                    val min : t -> t -> t
                    val max : t -> t -> t
                  end
                module Map :
                  sig
                    module Key :
                      sig
                        type t = Edge.graph
                        val t_of_sexp : Sexplib.Sexp.t -> t
                        val sexp_of_t : t -> Sexplib.Sexp.t
                        type comparator_witness = comparator_witness
                        val comparator :
                          (t, comparator_witness)
                          Core_kernel__.Comparator.comparator
                      end
                    module Tree :
                      sig
                        type 'a t =
                            (Key.t, 'a, comparator_witness)
                            Core_kernel__.Core_map_intf.Tree.t
                        val empty : 'a t
                        val singleton : Key.t -> '-> 'a t
                        val of_alist :
                          (Key.t * 'a) list ->
                          [ `Duplicate_key of Key.t | `Ok of 'a t ]
                        val of_alist_or_error :
                          (Key.t * 'a) list -> 'a t Base__.Or_error.t
                        val of_alist_exn : (Key.t * 'a) list -> 'a t
                        val of_alist_multi : (Key.t * 'a) list -> 'a list t
                        val of_alist_fold :
                          (Key.t * 'a) list ->
                          init:'-> f:('-> '-> 'b) -> 'b t
                        val of_alist_reduce :
                          (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                        val of_sorted_array :
                          (Key.t * 'a) array -> 'a t Base__.Or_error.t
                        val of_sorted_array_unchecked :
                          (Key.t * 'a) array -> 'a t
                        val of_increasing_iterator_unchecked :
                          len:int -> f:(int -> Key.t * 'a) -> 'a t
                        val of_iteri :
                          iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                          [ `Duplicate_key of Key.t | `Ok of 'v t ]
                        val of_tree : 'a t -> 'a t
                        val of_hashtbl_exn :
                          (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                        val gen :
                          Key.t Core_kernel__.Quickcheck.Generator.t ->
                          'Core_kernel__.Quickcheck.Generator.t ->
                          'a t Core_kernel__.Quickcheck.Generator.t
                        val invariants : 'a t -> bool
                        val is_empty : 'a t -> bool
                        val length : 'a t -> int
                        val add : 'a t -> key:Key.t -> data:'-> 'a t
                        val add_multi :
                          'a list t -> key:Key.t -> data:'-> 'a list t
                        val remove_multi : 'a list t -> Key.t -> 'a list t
                        val change :
                          'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                        val update :
                          'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                        val find : 'a t -> Key.t -> 'a option
                        val find_exn : 'a t -> Key.t -> 'a
                        val remove : 'a t -> Key.t -> 'a t
                        val mem : 'a t -> Key.t -> bool
                        val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                        val iter : 'a t -> f:('-> unit) -> unit
                        val iteri :
                          'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                        val iter2 :
                          'a t ->
                          'b t ->
                          f:(key:Key.t ->
                             data:[ `Both of 'a * 'b
                                  | `Left of 'a
                                  | `Right of 'b ] ->
                             unit) ->
                          unit
                        val map : 'a t -> f:('-> 'b) -> 'b t
                        val mapi :
                          'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                        val fold :
                          'a t ->
                          init:'->
                          f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                        val fold_right :
                          'a t ->
                          init:'->
                          f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                        val fold2 :
                          'a t ->
                          'b t ->
                          init:'->
                          f:(key:Key.t ->
                             data:[ `Both of 'a * 'b
                                  | `Left of 'a
                                  | `Right of 'b ] ->
                             '-> 'c) ->
                          'c
                        val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                        val filter : 'a t -> f:('-> bool) -> 'a t
                        val filteri :
                          'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                        val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                        val filter_mapi :
                          'a t ->
                          f:(key:Key.t -> data:'-> 'b option) -> 'b t
                        val partition_mapi :
                          'a t ->
                          f:(key:Key.t ->
                             data:'-> [ `Fst of '| `Snd of 'c ]) ->
                          'b t * 'c t
                        val partition_map :
                          'a t ->
                          f:('-> [ `Fst of '| `Snd of 'c ]) ->
                          'b t * 'c t
                        val partitioni_tf :
                          'a t ->
                          f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                        val partition_tf :
                          'a t -> f:('-> bool) -> 'a t * 'a t
                        val compare_direct :
                          ('-> '-> int) -> 'a t -> 'a t -> int
                        val equal :
                          ('-> '-> bool) -> 'a t -> 'a t -> bool
                        val keys : 'a t -> Key.t list
                        val data : 'a t -> 'a list
                        val to_alist :
                          ?key_order:[ `Decreasing | `Increasing ] ->
                          'a t -> (Key.t * 'a) list
                        val validate :
                          name:(Key.t -> string) ->
                          'Base__.Validate.check ->
                          'a t Base__.Validate.check
                        val merge :
                          'a t ->
                          'b t ->
                          f:(key:Key.t ->
                             [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                             'c option) ->
                          'c t
                        val symmetric_diff :
                          'a t ->
                          'a t ->
                          data_equal:('-> '-> bool) ->
                          (Key.t, 'a)
                          Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                          Base__.Sequence.t
                        val min_elt : 'a t -> (Key.t * 'a) option
                        val min_elt_exn : 'a t -> Key.t * 'a
                        val max_elt : 'a t -> (Key.t * 'a) option
                        val max_elt_exn : 'a t -> Key.t * 'a
                        val for_all : 'a t -> f:('-> bool) -> bool
                        val for_alli :
                          'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                        val exists : 'a t -> f:('-> bool) -> bool
                        val existsi :
                          'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                        val count : 'a t -> f:('-> bool) -> int
                        val counti :
                          'a t -> f:(key:Key.t -> data:'-> bool) -> int
                        val split :
                          'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                        val append :
                          lower_part:'a t ->
                          upper_part:'a t ->
                          [ `Ok of 'a t | `Overlapping_key_ranges ]
                        val subrange :
                          'a t ->
                          lower_bound:Key.t Base__.Maybe_bound.t ->
                          upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                        val fold_range_inclusive :
                          'a t ->
                          min:Key.t ->
                          max:Key.t ->
                          init:'->
                          f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                        val range_to_alist :
                          'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                        val closest_key :
                          'a t ->
                          [ `Greater_or_equal_to
                          | `Greater_than
                          | `Less_or_equal_to
                          | `Less_than ] -> Key.t -> (Key.t * 'a) option
                        val nth : 'a t -> int -> (Key.t * 'a) option
                        val nth_exn : 'a t -> int -> Key.t * 'a
                        val rank : 'a t -> Key.t -> int option
                        val to_tree : 'a t -> 'a t
                        val to_sequence :
                          ?order:[ `Decreasing_key | `Increasing_key ] ->
                          ?keys_greater_or_equal_to:Key.t ->
                          ?keys_less_or_equal_to:Key.t ->
                          'a t -> (Key.t * 'a) Base__.Sequence.t
                        val obs :
                          Key.t Core_kernel__.Quickcheck.Observer.t ->
                          'Core_kernel__.Quickcheck.Observer.t ->
                          'v t Core_kernel__.Quickcheck.Observer.t
                        val shrinker :
                          Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                          'Core_kernel__.Quickcheck.Shrinker.t ->
                          'v t Core_kernel__.Quickcheck.Shrinker.t
                        module Provide_of_sexp :
                          functor
                            (K : sig
                                   val t_of_sexp : Sexplib.Sexp.t -> Key.t
                                 end->
                            sig
                              val t_of_sexp :
                                (Sexplib.Sexp.t -> 'v_x__017_) ->
                                Sexplib.Sexp.t -> 'v_x__017_ t
                            end
                        val t_of_sexp :
                          (Base__.Sexplib.Sexp.t -> 'a) ->
                          Base__.Sexplib.Sexp.t -> 'a t
                        val sexp_of_t :
                          ('-> Base__.Sexplib.Sexp.t) ->
                          'a t -> Base__.Sexplib.Sexp.t
                      end
                    type 'a t =
                        (Key.t, 'a, comparator_witness)
                        Core_kernel__.Core_map_intf.Map.t
                    val compare :
                      ('-> '-> Core_kernel__.Import.int) ->
                      'a t -> 'a t -> Core_kernel__.Import.int
                    val empty : 'a t
                    val singleton : Key.t -> '-> 'a t
                    val of_alist :
                      (Key.t * 'a) list ->
                      [ `Duplicate_key of Key.t | `Ok of 'a t ]
                    val of_alist_or_error :
                      (Key.t * 'a) list -> 'a t Base__.Or_error.t
                    val of_alist_exn : (Key.t * 'a) list -> 'a t
                    val of_alist_multi : (Key.t * 'a) list -> 'a list t
                    val of_alist_fold :
                      (Key.t * 'a) list ->
                      init:'-> f:('-> '-> 'b) -> 'b t
                    val of_alist_reduce :
                      (Key.t * 'a) list -> f:('-> '-> 'a) -> 'a t
                    val of_sorted_array :
                      (Key.t * 'a) array -> 'a t Base__.Or_error.t
                    val of_sorted_array_unchecked :
                      (Key.t * 'a) array -> 'a t
                    val of_increasing_iterator_unchecked :
                      len:int -> f:(int -> Key.t * 'a) -> 'a t
                    val of_iteri :
                      iteri:(f:(key:Key.t -> data:'-> unit) -> unit) ->
                      [ `Duplicate_key of Key.t | `Ok of 'v t ]
                    val of_tree : 'Tree.t -> 'a t
                    val of_hashtbl_exn :
                      (Key.t, 'a) Core_kernel__.Core_hashtbl.t -> 'a t
                    val gen :
                      Key.t Core_kernel__.Quickcheck.Generator.t ->
                      'Core_kernel__.Quickcheck.Generator.t ->
                      'a t Core_kernel__.Quickcheck.Generator.t
                    val invariants : 'a t -> bool
                    val is_empty : 'a t -> bool
                    val length : 'a t -> int
                    val add : 'a t -> key:Key.t -> data:'-> 'a t
                    val add_multi :
                      'a list t -> key:Key.t -> data:'-> 'a list t
                    val remove_multi : 'a list t -> Key.t -> 'a list t
                    val change :
                      'a t -> Key.t -> f:('a option -> 'a option) -> 'a t
                    val update : 'a t -> Key.t -> f:('a option -> 'a) -> 'a t
                    val find : 'a t -> Key.t -> 'a option
                    val find_exn : 'a t -> Key.t -> 'a
                    val remove : 'a t -> Key.t -> 'a t
                    val mem : 'a t -> Key.t -> bool
                    val iter_keys : 'a t -> f:(Key.t -> unit) -> unit
                    val iter : 'a t -> f:('-> unit) -> unit
                    val iteri :
                      'a t -> f:(key:Key.t -> data:'-> unit) -> unit
                    val iter2 :
                      'a t ->
                      'b t ->
                      f:(key:Key.t ->
                         data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                         unit) ->
                      unit
                    val map : 'a t -> f:('-> 'b) -> 'b t
                    val mapi : 'a t -> f:(key:Key.t -> data:'-> 'b) -> 'b t
                    val fold :
                      'a t ->
                      init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                    val fold_right :
                      'a t ->
                      init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                    val fold2 :
                      'a t ->
                      'b t ->
                      init:'->
                      f:(key:Key.t ->
                         data:[ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                         '-> 'c) ->
                      'c
                    val filter_keys : 'a t -> f:(Key.t -> bool) -> 'a t
                    val filter : 'a t -> f:('-> bool) -> 'a t
                    val filteri :
                      'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t
                    val filter_map : 'a t -> f:('-> 'b option) -> 'b t
                    val filter_mapi :
                      'a t -> f:(key:Key.t -> data:'-> 'b option) -> 'b t
                    val partition_mapi :
                      'a t ->
                      f:(key:Key.t -> data:'-> [ `Fst of '| `Snd of 'c ]) ->
                      'b t * 'c t
                    val partition_map :
                      'a t ->
                      f:('-> [ `Fst of '| `Snd of 'c ]) -> 'b t * 'c t
                    val partitioni_tf :
                      'a t -> f:(key:Key.t -> data:'-> bool) -> 'a t * 'a t
                    val partition_tf : 'a t -> f:('-> bool) -> 'a t * 'a t
                    val compare_direct :
                      ('-> '-> int) -> 'a t -> 'a t -> int
                    val equal : ('-> '-> bool) -> 'a t -> 'a t -> bool
                    val keys : 'a t -> Key.t list
                    val data : 'a t -> 'a list
                    val to_alist :
                      ?key_order:[ `Decreasing | `Increasing ] ->
                      'a t -> (Key.t * 'a) list
                    val validate :
                      name:(Key.t -> string) ->
                      'Base__.Validate.check -> 'a t Base__.Validate.check
                    val merge :
                      'a t ->
                      'b t ->
                      f:(key:Key.t ->
                         [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                         'c option) ->
                      'c t
                    val symmetric_diff :
                      'a t ->
                      'a t ->
                      data_equal:('-> '-> bool) ->
                      (Key.t, 'a)
                      Core_kernel__.Core_map_intf.Map_intf.Symmetric_diff_element.t
                      Base__.Sequence.t
                    val min_elt : 'a t -> (Key.t * 'a) option
                    val min_elt_exn : 'a t -> Key.t * 'a
                    val max_elt : 'a t -> (Key.t * 'a) option
                    val max_elt_exn : 'a t -> Key.t * 'a
                    val for_all : 'a t -> f:('-> bool) -> bool
                    val for_alli :
                      'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                    val exists : 'a t -> f:('-> bool) -> bool
                    val existsi :
                      'a t -> f:(key:Key.t -> data:'-> bool) -> bool
                    val count : 'a t -> f:('-> bool) -> int
                    val counti :
                      'a t -> f:(key:Key.t -> data:'-> bool) -> int
                    val split :
                      'a t -> Key.t -> 'a t * (Key.t * 'a) option * 'a t
                    val append :
                      lower_part:'a t ->
                      upper_part:'a t ->
                      [ `Ok of 'a t | `Overlapping_key_ranges ]
                    val subrange :
                      'a t ->
                      lower_bound:Key.t Base__.Maybe_bound.t ->
                      upper_bound:Key.t Base__.Maybe_bound.t -> 'a t
                    val fold_range_inclusive :
                      'a t ->
                      min:Key.t ->
                      max:Key.t ->
                      init:'-> f:(key:Key.t -> data:'-> '-> 'b) -> 'b
                    val range_to_alist :
                      'a t -> min:Key.t -> max:Key.t -> (Key.t * 'a) list
                    val closest_key :
                      'a t ->
                      [ `Greater_or_equal_to
                      | `Greater_than
                      | `Less_or_equal_to
                      | `Less_than ] -> Key.t -> (Key.t * 'a) option
                    val nth : 'a t -> int -> (Key.t * 'a) option
                    val nth_exn : 'a t -> int -> Key.t * 'a
                    val rank : 'a t -> Key.t -> int option
                    val to_tree : 'a t -> 'Tree.t
                    val to_sequence :
                      ?order:[ `Decreasing_key | `Increasing_key ] ->
                      ?keys_greater_or_equal_to:Key.t ->
                      ?keys_less_or_equal_to:Key.t ->
                      'a t -> (Key.t * 'a) Base__.Sequence.t
                    val obs :
                      Key.t Core_kernel__.Quickcheck.Observer.t ->
                      'Core_kernel__.Quickcheck.Observer.t ->
                      'v t Core_kernel__.Quickcheck.Observer.t
                    val shrinker :
                      Key.t Core_kernel__.Quickcheck.Shrinker.t ->
                      'Core_kernel__.Quickcheck.Shrinker.t ->
                      'v t Core_kernel__.Quickcheck.Shrinker.t
                    module Provide_of_sexp :
                      functor
                        (Key : sig
                                 val t_of_sexp : Sexplib.Sexp.t -> Key.t
                               end->
                        sig
                          val t_of_sexp :
                            (Sexplib.Sexp.t -> 'v_x__018_) ->
                            Sexplib.Sexp.t -> 'v_x__018_ t
                        end
                    module Provide_bin_io :
                      functor
                        (Key : sig
                                 val bin_t : Key.t Bin_prot.Type_class.t
                                 val bin_read_t : Key.t Bin_prot.Read.reader
                                 val __bin_read_t__ :
                                   (Core_kernel__.Import.int -> Key.t)
                                   Bin_prot.Read.reader
                                 val bin_reader_t :
                                   Key.t Bin_prot.Type_class.reader
                                 val bin_size_t : Key.t Bin_prot.Size.sizer
                                 val bin_write_t :
                                   Key.t Bin_prot.Write.writer
                                 val bin_writer_t :
                                   Key.t Bin_prot.Type_class.writer
                                 val bin_shape_t : Bin_prot.Shape.t
                               end->
                        sig
                          val bin_shape_t :
                            Bin_prot.Shape.t -> Bin_prot.Shape.t
                          val bin_size_t : ('a, 'a t) Bin_prot.Size.sizer1
                          val bin_write_t : ('a, 'a t) Bin_prot.Write.writer1
                          val bin_read_t : ('a, 'a t) Bin_prot.Read.reader1
                          val __bin_read_t__ :
                            ('a, int -> 'a t) Bin_prot.Read.reader1
                          val bin_writer_t :
                            ('a, 'a t) Bin_prot.Type_class.S1.writer
                          val bin_reader_t :
                            ('a, 'a t) Bin_prot.Type_class.S1.reader
                          val bin_t : ('a, 'a t) Bin_prot.Type_class.S1.t
                        end
                    module Provide_hash :
                      functor
                        (Key : sig
                                 val hash_fold_t :
                                   Base__.Hash.state ->
                                   Key.t -> Base__.Hash.state
                               end->
                        sig
                          val hash_fold_t :
                            (Ppx_hash_lib.Std.Hash.state ->
                             '-> Ppx_hash_lib.Std.Hash.state) ->
                            Ppx_hash_lib.Std.Hash.state ->
                            'a t -> Ppx_hash_lib.Std.Hash.state
                        end
                    val t_of_sexp :
                      (Base__.Sexplib.Sexp.t -> 'a) ->
                      Base__.Sexplib.Sexp.t -> 'a t
                    val sexp_of_t :
                      ('-> Base__.Sexplib.Sexp.t) ->
                      'a t -> Base__.Sexplib.Sexp.t
                  end
                module Set :
                  sig
                    module Elt :
                      sig
                        type t = Edge.graph
                        val t_of_sexp : Sexplib.Sexp.t -> t
                        val sexp_of_t : t -> Sexplib.Sexp.t
                        type comparator_witness = Map.Key.comparator_witness
                        val comparator :
                          (t, comparator_witness)
                          Core_kernel__.Comparator.comparator
                      end
                    module Tree :
                      sig
                        type t =
                            (Elt.t, comparator_witness)
                            Core_kernel__.Core_set_intf.Tree.t
                        val compare : t -> t -> Core_kernel__.Import.int
                        val length : t -> int
                        val is_empty : t -> bool
                        val iter : t -> f:(Elt.t -> unit) -> unit
                        val fold :
                          t ->
                          init:'accum ->
                          f:('accum -> Elt.t -> 'accum) -> 'accum
                        val fold_result :
                          t ->
                          init:'accum ->
                          f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                          ('accum, 'e) Base__.Result.t
                        val exists : t -> f:(Elt.t -> bool) -> bool
                        val for_all : t -> f:(Elt.t -> bool) -> bool
                        val count : t -> f:(Elt.t -> bool) -> int
                        val sum :
                          (module Base__.Commutative_group.S with type t = 'sum) ->
                          t -> f:(Elt.t -> 'sum) -> 'sum
                        val find : t -> f:(Elt.t -> bool) -> Elt.t option
                        val find_map :
                          t -> f:(Elt.t -> 'a option) -> 'a option
                        val to_list : t -> Elt.t list
                        val to_array : t -> Elt.t array
                        val invariants : t -> bool
                        val mem : t -> Elt.t -> bool
                        val add : t -> Elt.t -> t
                        val remove : t -> Elt.t -> t
                        val union : t -> t -> t
                        val inter : t -> t -> t
                        val diff : t -> t -> t
                        val symmetric_diff :
                          t ->
                          t ->
                          (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                        val compare_direct : t -> t -> int
                        val equal : t -> t -> bool
                        val is_subset : t -> of_:t -> bool
                        val subset : t -> t -> bool
                        val fold_until :
                          t ->
                          init:'->
                          f:('->
                             Elt.t ->
                             ('b, 'stop)
                             Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                          ('b, 'stop)
                          Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                        val fold_right :
                          t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                        val iter2 :
                          t ->
                          t ->
                          f:([ `Both of Elt.t * Elt.t
                             | `Left of Elt.t
                             | `Right of Elt.t ] -> unit) ->
                          unit
                        val filter : t -> f:(Elt.t -> bool) -> t
                        val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                        val elements : t -> Elt.t list
                        val min_elt : t -> Elt.t option
                        val min_elt_exn : t -> Elt.t
                        val max_elt : t -> Elt.t option
                        val max_elt_exn : t -> Elt.t
                        val choose : t -> Elt.t option
                        val choose_exn : t -> Elt.t
                        val split : t -> Elt.t -> t * Elt.t option * t
                        val group_by :
                          t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                        val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                        val find_index : t -> int -> Elt.t option
                        val nth : t -> int -> Elt.t option
                        val remove_index : t -> int -> t
                        val to_tree : t -> t
                        val to_sequence :
                          ?order:[ `Decreasing | `Increasing ] ->
                          ?greater_or_equal_to:Elt.t ->
                          ?less_or_equal_to:Elt.t ->
                          t -> Elt.t Base__.Sequence.t
                        val merge_to_sequence :
                          ?order:[ `Decreasing | `Increasing ] ->
                          ?greater_or_equal_to:Elt.t ->
                          ?less_or_equal_to:Elt.t ->
                          t ->
                          t ->
                          (Elt.t, Elt.t)
                          Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                          Base__.Sequence.t
                        val to_map :
                          t ->
                          f:(Elt.t -> 'data) ->
                          (Elt.t, 'data, comparator_witness)
                          Core_kernel__.Core_set_intf.Map.t
                        val obs :
                          Elt.t Core_kernel__.Quickcheck.Observer.t ->
                          t Core_kernel__.Quickcheck.Observer.t
                        val shrinker :
                          Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                          t Core_kernel__.Quickcheck.Shrinker.t
                        val empty : t
                        val singleton : Elt.t -> t
                        val union_list : t list -> t
                        val of_list : Elt.t list -> t
                        val of_array : Elt.t array -> t
                        val of_sorted_array :
                          Elt.t array -> t Base__.Or_error.t
                        val of_sorted_array_unchecked : Elt.t array -> t
                        val of_increasing_iterator_unchecked :
                          len:int -> f:(int -> Elt.t) -> t
                        val stable_dedup_list : Elt.t list -> Elt.t list
                        val map :
                          ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                          f:('-> Elt.t) -> t
                        val filter_map :
                          ('a, 'b) Core_kernel__.Core_set_intf.Tree.t ->
                          f:('-> Elt.t option) -> t
                        val of_tree : t -> t
                        val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                        val of_hashtbl_keys :
                          (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                        val of_map_keys :
                          (Elt.t, 'a, comparator_witness)
                          Core_kernel__.Core_set_intf.Map.t -> t
                        val gen :
                          Elt.t Core_kernel__.Quickcheck.Generator.t ->
                          t Core_kernel__.Quickcheck.Generator.t
                        module Provide_of_sexp :
                          functor
                            (Elt : sig
                                     val t_of_sexp : Sexplib.Sexp.t -> Elt.t
                                   end->
                            sig val t_of_sexp : Sexplib.Sexp.t -> t end
                        val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                        val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                      end
                    type t = (Elt.t, comparator_witness) Base.Set.t
                    val compare : t -> t -> Core_kernel__.Import.int
                    val length : t -> int
                    val is_empty : t -> bool
                    val iter : t -> f:(Elt.t -> unit) -> unit
                    val fold :
                      t ->
                      init:'accum -> f:('accum -> Elt.t -> 'accum) -> 'accum
                    val fold_result :
                      t ->
                      init:'accum ->
                      f:('accum -> Elt.t -> ('accum, 'e) Base__.Result.t) ->
                      ('accum, 'e) Base__.Result.t
                    val exists : t -> f:(Elt.t -> bool) -> bool
                    val for_all : t -> f:(Elt.t -> bool) -> bool
                    val count : t -> f:(Elt.t -> bool) -> int
                    val sum :
                      (module Base__.Commutative_group.S with type t = 'sum) ->
                      t -> f:(Elt.t -> 'sum) -> 'sum
                    val find : t -> f:(Elt.t -> bool) -> Elt.t option
                    val find_map : t -> f:(Elt.t -> 'a option) -> 'a option
                    val to_list : t -> Elt.t list
                    val to_array : t -> Elt.t array
                    val invariants : t -> bool
                    val mem : t -> Elt.t -> bool
                    val add : t -> Elt.t -> t
                    val remove : t -> Elt.t -> t
                    val union : t -> t -> t
                    val inter : t -> t -> t
                    val diff : t -> t -> t
                    val symmetric_diff :
                      t ->
                      t -> (Elt.t, Elt.t) Base__.Either.t Base__.Sequence.t
                    val compare_direct : t -> t -> int
                    val equal : t -> t -> bool
                    val is_subset : t -> of_:t -> bool
                    val subset : t -> t -> bool
                    val fold_until :
                      t ->
                      init:'->
                      f:('->
                         Elt.t ->
                         ('b, 'stop)
                         Core_kernel__.Core_set_intf.Set_intf.Continue_or_stop.t) ->
                      ('b, 'stop)
                      Core_kernel__.Core_set_intf.Set_intf.Finished_or_stopped_early.t
                    val fold_right :
                      t -> init:'-> f:(Elt.t -> '-> 'b) -> 'b
                    val iter2 :
                      t ->
                      t ->
                      f:([ `Both of Elt.t * Elt.t
                         | `Left of Elt.t
                         | `Right of Elt.t ] -> unit) ->
                      unit
                    val filter : t -> f:(Elt.t -> bool) -> t
                    val partition_tf : t -> f:(Elt.t -> bool) -> t * t
                    val elements : t -> Elt.t list
                    val min_elt : t -> Elt.t option
                    val min_elt_exn : t -> Elt.t
                    val max_elt : t -> Elt.t option
                    val max_elt_exn : t -> Elt.t
                    val choose : t -> Elt.t option
                    val choose_exn : t -> Elt.t
                    val split : t -> Elt.t -> t * Elt.t option * t
                    val group_by :
                      t -> equiv:(Elt.t -> Elt.t -> bool) -> t list
                    val find_exn : t -> f:(Elt.t -> bool) -> Elt.t
                    val find_index : t -> int -> Elt.t option
                    val nth : t -> int -> Elt.t option
                    val remove_index : t -> int -> t
                    val to_tree : t -> Tree.t
                    val to_sequence :
                      ?order:[ `Decreasing | `Increasing ] ->
                      ?greater_or_equal_to:Elt.t ->
                      ?less_or_equal_to:Elt.t -> t -> Elt.t Base__.Sequence.t
                    val merge_to_sequence :
                      ?order:[ `Decreasing | `Increasing ] ->
                      ?greater_or_equal_to:Elt.t ->
                      ?less_or_equal_to:Elt.t ->
                      t ->
                      t ->
                      (Elt.t, Elt.t)
                      Core_kernel__.Core_set_intf.Set_intf.Merge_to_sequence_element.t
                      Base__.Sequence.t
                    val to_map :
                      t ->
                      f:(Elt.t -> 'data) ->
                      (Elt.t, 'data, comparator_witness)
                      Core_kernel__.Core_set_intf.Map.t
                    val obs :
                      Elt.t Core_kernel__.Quickcheck.Observer.t ->
                      t Core_kernel__.Quickcheck.Observer.t
                    val shrinker :
                      Elt.t Core_kernel__.Quickcheck.Shrinker.t ->
                      t Core_kernel__.Quickcheck.Shrinker.t
                    val empty : t
                    val singleton : Elt.t -> t
                    val union_list : t list -> t
                    val of_list : Elt.t list -> t
                    val of_array : Elt.t array -> t
                    val of_sorted_array : Elt.t array -> t Base__.Or_error.t
                    val of_sorted_array_unchecked : Elt.t array -> t
                    val of_increasing_iterator_unchecked :
                      len:int -> f:(int -> Elt.t) -> t
                    val stable_dedup_list : Elt.t list -> Elt.t list
                    val map : ('a, 'b) Base.Set.t -> f:('-> Elt.t) -> t
                    val filter_map :
                      ('a, 'b) Base.Set.t -> f:('-> Elt.t option) -> t
                    val of_tree : Tree.t -> t
                    val of_hash_set : Elt.t Core_kernel__.Hash_set.t -> t
                    val of_hashtbl_keys :
                      (Elt.t, 'a) Core_kernel__.Core_hashtbl.t -> t
                    val of_map_keys :
                      (Elt.t, 'a, comparator_witness)
                      Core_kernel__.Core_set_intf.Map.t -> t
                    val gen :
                      Elt.t Core_kernel__.Quickcheck.Generator.t ->
                      t Core_kernel__.Quickcheck.Generator.t
                    module Provide_of_sexp :
                      functor
                        (Elt : sig
                                 val t_of_sexp : Sexplib.Sexp.t -> Elt.t
                               end->
                        sig val t_of_sexp : Sexplib.Sexp.t -> t end
                    module Provide_bin_io :
                      functor
                        (Elt : sig
                                 val bin_t : Elt.t Bin_prot.Type_class.t
                                 val bin_read_t : Elt.t Bin_prot.Read.reader
                                 val __bin_read_t__ :
                                   (Core_kernel__.Import.int -> Elt.t)
                                   Bin_prot.Read.reader
                                 val bin_reader_t :
                                   Elt.t Bin_prot.Type_class.reader
                                 val bin_size_t : Elt.t Bin_prot.Size.sizer
                                 val bin_write_t :
                                   Elt.t Bin_prot.Write.writer
                                 val bin_writer_t :
                                   Elt.t Bin_prot.Type_class.writer
                                 val bin_shape_t : Bin_prot.Shape.t
                               end->
                        sig
                          val bin_size_t : t Bin_prot.Size.sizer
                          val bin_write_t : t Bin_prot.Write.writer
                          val bin_read_t : t Bin_prot.Read.reader
                          val __bin_read_t__ :
                            (int -> t) Bin_prot.Read.reader
                          val bin_shape_t : Bin_prot.Shape.t
                          val bin_writer_t : t Bin_prot.Type_class.writer
                          val bin_reader_t : t Bin_prot.Type_class.reader
                          val bin_t : t Bin_prot.Type_class.t
                        end
                    module Provide_hash :
                      functor
                        (Elt : sig
                                 val hash_fold_t :
                                   Base__.Hash.state ->
                                   Elt.t -> Base__.Hash.state
                               end->
                        sig
                          val hash_fold_t :
                            Ppx_hash_lib.Std.Hash.state ->
                            t -> Ppx_hash_lib.Std.Hash.state
                          val hash : t -> Ppx_hash_lib.Std.Hash.hash_value
                        end
                    val t_of_sexp : Base__.Sexplib.Sexp.t -> t
                    val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                  end
                val hash : t -> Core_kernel__.Import.int
                val compare : t -> t -> Core_kernel__.Import.int
                val hashable : t Core_kernel.Std.Hashable.Hashtbl.Hashable.t
                module Table :
                  sig
                    type key = t
                    type ('a, 'b) hashtbl = ('a, 'b) Edge.Table.hashtbl
                    type 'b t = (key, 'b) hashtbl
                    val sexp_of_t :
                      ('-> Sexplib.Sexp.t) -> 'b t -> Sexplib.Sexp.t
                    type ('a, 'b) t_ = 'b t
                    type 'a key_ = key
                    val hashable :
                      key Core_kernel__.Core_hashtbl_intf.Hashable.t
                    val invariant :
                      'Base__.Invariant_intf.inv ->
                      'a t Base__.Invariant_intf.inv
                    val create :
                      (key, 'b, unit -> 'b t)
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val of_alist :
                      (key, 'b,
                       (key * 'b) list ->
                       [ `Duplicate_key of key | `Ok of 'b t ])
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val of_alist_report_all_dups :
                      (key, 'b,
                       (key * 'b) list ->
                       [ `Duplicate_keys of key list | `Ok of 'b t ])
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val of_alist_or_error :
                      (key, 'b, (key * 'b) list -> 'b t Base__.Or_error.t)
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val of_alist_exn :
                      (key, 'b, (key * 'b) list -> 'b t)
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val of_alist_multi :
                      (key, 'b list, (key * 'b) list -> 'b list t)
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val create_mapped :
                      (key, 'b,
                       get_key:('-> key) ->
                       get_data:('-> 'b) ->
                       'r list ->
                       [ `Duplicate_keys of key list | `Ok of 'b t ])
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val create_with_key :
                      (key, 'r,
                       get_key:('-> key) ->
                       'r list ->
                       [ `Duplicate_keys of key list | `Ok of 'r t ])
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val create_with_key_or_error :
                      (key, 'r,
                       get_key:('-> key) ->
                       'r list -> 'r t Base__.Or_error.t)
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val create_with_key_exn :
                      (key, 'r, get_key:('-> key) -> 'r list -> 'r t)
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val group :
                      (key, 'b,
                       get_key:('-> key) ->
                       get_data:('-> 'b) ->
                       combine:('-> '-> 'b) -> 'r list -> 'b t)
                      Core_kernel__.Core_hashtbl_intf.create_options_without_hashable
                    val sexp_of_key : 'a t -> key -> Base__.Sexp.t
                    val clear : 'a t -> unit
                    val copy : 'b t -> 'b t
                    val fold :
                      'b t ->
                      init:'-> f:(key:key -> data:'-> '-> 'c) -> 'c
                    val iter_keys : 'a t -> f:(key -> unit) -> unit
                    val iter : 'b t -> f:('-> unit) -> unit
                    val iteri :
                      'b t -> f:(key:key -> data:'-> unit) -> unit
                    val iter_vals : 'b t -> f:('-> unit) -> unit
                    val existsi :
                      'b t -> f:(key:key -> data:'-> bool) -> bool
                    val exists : 'b t -> f:('-> bool) -> bool
                    val for_alli :
                      'b t -> f:(key:key -> data:'-> bool) -> bool
                    val for_all : 'b t -> f:('-> bool) -> bool
                    val counti :
                      'b t -> f:(key:key -> data:'-> bool) -> int
                    val count : 'b t -> f:('-> bool) -> int
                    val length : 'a t -> int
                    val is_empty : 'a t -> bool
                    val mem : 'a t -> key -> bool
                    val remove : 'a t -> key -> unit
                    val replace : 'b t -> key:key -> data:'-> unit
                    val set : 'b t -> key:key -> data:'-> unit
                    val add :
                      'b t -> key:key -> data:'-> [ `Duplicate | `Ok ]
                    val add_or_error :
                      'b t -> key:key -> data:'-> unit Base__.Or_error.t
                    val add_exn : 'b t -> key:key -> data:'-> unit
                    val change :
                      'b t -> key -> f:('b option -> 'b option) -> unit
                    val update : 'b t -> key -> f:('b option -> 'b) -> unit
                    val add_multi : 'b list t -> key:key -> data:'-> unit
                    val remove_multi : 'a list t -> key -> unit
                    val map : 'b t -> f:('-> 'c) -> 'c t
                    val mapi : 'b t -> f:(key:key -> data:'-> 'c) -> 'c t
                    val filter_map : 'b t -> f:('-> 'c option) -> 'c t
                    val filter_mapi :
                      'b t -> f:(key:key -> data:'-> 'c option) -> 'c t
                    val filter_keys : 'b t -> f:(key -> bool) -> 'b t
                    val filter : 'b t -> f:('-> bool) -> 'b t
                    val filteri :
                      'b t -> f:(key:key -> data:'-> bool) -> 'b t
                    val partition_map :
                      'b t ->
                      f:('-> [ `Fst of '| `Snd of 'd ]) -> 'c t * 'd t
                    val partition_mapi :
                      'b t ->
                      f:(key:key -> data:'-> [ `Fst of '| `Snd of 'd ]) ->
                      'c t * 'd t
                    val partition_tf : 'b t -> f:('-> bool) -> 'b t * 'b t
                    val partitioni_tf :
                      'b t -> f:(key:key -> data:'-> bool) -> 'b t * 'b t
                    val find_or_add :
                      'b t -> key -> default:(unit -> 'b) -> 'b
                    val find : 'b t -> key -> 'b option
                    val find_exn : 'b t -> key -> 'b
                    val find_and_call :
                      'b t ->
                      key ->
                      if_found:('-> 'c) -> if_not_found:(key -> 'c) -> 'c
                    val find_and_remove : 'b t -> key -> 'b option
                    val merge :
                      'a t ->
                      'b t ->
                      f:(key:key ->
                         [ `Both of 'a * '| `Left of '| `Right of 'b ] ->
                         'c option) ->
                      'c t
                    type 'a merge_into_action = Remove | Set_to of 'a
                    val merge_into :
                      src:'a t ->
                      dst:'b t ->
                      f:(key:key -> '-> 'b option -> 'b merge_into_action) ->
                      unit
                    val keys : 'a t -> key list
                    val data : 'b t -> 'b list
                    val filter_keys_inplace : 'a t -> f:(key -> bool) -> unit
                    val filter_inplace : 'b t -> f:('-> bool) -> unit
                    val filteri_inplace :
                      'b t -> f:(key:key -> data:'-> bool) -> unit
                    val map_inplace : 'b t -> f:('-> 'b) -> unit
                    val mapi_inplace :
                      'b t -> f:(key:key -> data:'-> 'b) -> unit
                    val filter_map_inplace :
                      'b t -> f:('-> 'b option) -> unit
                    val filter_mapi_inplace :
                      'b t -> f:(key:key -> data:'-> 'b option) -> unit
                    val replace_all : 'b t -> f:('-> 'b) -> unit
                    val replace_alli :
                      'b t -> f:(key:key -> data:'-> 'b) -> unit
                    val filter_replace_all :
                      'b t -> f:('-> 'b option) -> unit
                    val filter_replace_alli :
                      'b t -> f:(key:key -> data:'-> 'b option) -> unit
                    val equal : 'b t -> 'b t -> ('-> '-> bool) -> bool
                    val similar :
                      'b1 t -> 'b2 t -> ('b1 -> 'b2 -> bool) -> bool
                    val to_alist : 'b t -> (key * 'b) list
                    val validate :
                      name:(key -> string) ->
                      'Base__.Validate.check -> 'b t Base__.Validate.check
                    val incr :
                      ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                    val decr :
                      ?by:int -> ?remove_if_zero:bool -> int t -> key -> unit
                    module Provide_of_sexp :
                      functor
                        (Key : sig val t_of_sexp : Sexplib.Sexp.t -> key end->
                        sig
                          val t_of_sexp :
                            (Sexplib.Sexp.t -> 'v_x__001_) ->
                            Sexplib.Sexp.t -> 'v_x__001_ t
                        end
                    module Provide_bin_io :
                      functor
                        (Key : sig
                                 val bin_t : key Bin_prot.Type_class.t
                                 val bin_read_t : key Bin_prot.Read.reader
                                 val __bin_read_t__ :
                                   (Core_kernel__.Import.int -> key)
                                   Bin_prot.Read.reader
                                 val bin_reader_t :
                                   key Bin_prot.Type_class.reader
                                 val bin_size_t : key Bin_prot.Size.sizer
                                 val bin_write_t : key Bin_prot.Write.writer
                                 val bin_writer_t :
                                   key Bin_prot.Type_class.writer
                                 val bin_shape_t : Bin_prot.Shape.t
                               end->
                        sig
                          val bin_t :
                            'Bin_prot.Type_class.t ->
                            'a t Bin_prot.Type_class.t
                          val bin_read_t :
                            'Bin_prot.Read.reader ->
                            'a t Bin_prot.Read.reader
                          val __bin_read_t__ :
                            'Bin_prot.Read.reader ->
                            (Core_kernel__.Import.int -> 'a t)
                            Bin_prot.Read.reader
                          val bin_reader_t :
                            'Bin_prot.Type_class.reader ->
                            'a t Bin_prot.Type_class.reader
                          val bin_size_t :
                            'Bin_prot.Size.sizer ->
                            'a t Bin_prot.Size.sizer
                          val bin_write_t :
                            'Bin_prot.Write.writer ->
                            'a t Bin_prot.Write.writer
                          val bin_writer_t :
                            'Bin_prot.Type_class.writer ->
                            'a t Bin_prot.Type_class.writer
                          val bin_shape_t :
                            Bin_prot.Shape.t -> Bin_prot.Shape.t
                        end
                    val t_of_sexp :
                      (Sexplib.Sexp.t -> 'v_x__002_) ->
                      Sexplib.Sexp.t -> 'v_x__002_ t
                  end
                module Hash_set :
                  sig
                    type elt = t
                    type t = elt Core_kernel__.Hash_set.t
                    val sexp_of_t : t -> Sexplib.Sexp.t
                    type 'a t_ = t
                    type 'a elt_ = elt
                    val create :
                      ('a, unit -> t)
                      Core_kernel__.Hash_set_intf.create_options_without_hashable
                    val of_list :
                      ('a, elt list -> t)
                      Core_kernel__.Hash_set_intf.create_options_without_hashable
                    module Provide_of_sexp :
                      functor
                        (X : sig val t_of_sexp : Sexplib.Sexp.t -> elt end->
                        sig val t_of_sexp : Sexplib.Sexp.t -> t end
                    module Provide_bin_io :
                      functor
                        (X : sig
                               val bin_t : elt Bin_prot.Type_class.t
                               val bin_read_t : elt Bin_prot.Read.reader
                               val __bin_read_t__ :
                                 (Core_kernel__.Import.int -> elt)
                                 Bin_prot.Read.reader
                               val bin_reader_t :
                                 elt Bin_prot.Type_class.reader
                               val bin_size_t : elt Bin_prot.Size.sizer
                               val bin_write_t : elt Bin_prot.Write.writer
                               val bin_writer_t :
                                 elt Bin_prot.Type_class.writer
                               val bin_shape_t : Bin_prot.Shape.t
                             end->
                        sig
                          val bin_t : t Bin_prot.Type_class.t
                          val bin_read_t : t Bin_prot.Read.reader
                          val __bin_read_t__ :
                            (Core_kernel__.Import.int -> t)
                            Bin_prot.Read.reader
                          val bin_reader_t : t Bin_prot.Type_class.reader
                          val bin_size_t : t Bin_prot.Size.sizer
                          val bin_write_t : t Bin_prot.Write.writer
                          val bin_writer_t : t Bin_prot.Type_class.writer
                          val bin_shape_t : Bin_prot.Shape.t
                        end
                    val t_of_sexp : Sexplib.Sexp.t -> t
                  end
                module Hash_queue :
                  sig
                    module Key :
                      sig
                        type t = Hash_set.elt
                        val sexp_of_t : t -> Base__.Sexplib.Sexp.t
                        val compare : t -> t -> int
                        val hash : t -> int
                      end
                    type 'a t
                    val sexp_of_t :
                      ('-> Sexplib.Sexp.t) -> 'a t -> Sexplib.Sexp.t
                    val length : 'a t -> int
                    val is_empty : 'a t -> bool
                    val iter : 'a t -> f:('-> unit) -> unit
                    val fold :
                      'a t ->
                      init:'accum -> f:('accum -> '-> 'accum) -> 'accum
                    val fold_result :
                      'a t ->
                      init:'accum ->
                      f:('accum -> '-> ('accum, 'e) Base__.Result.t) ->
                      ('accum, 'e) Base__.Result.t
                    val fold_until :
                      'a t ->
                      init:'accum ->
                      f:('accum ->
                         '->
                         ('accum, 'stop)
                         Base.Container_intf.Continue_or_stop.t) ->
                      ('accum, 'stop)
                      Base.Container_intf.Finished_or_stopped_early.t
                    val exists : 'a t -> f:('-> bool) -> bool
                    val for_all : 'a t -> f:('-> bool) -> bool
                    val count : 'a t -> f:('-> bool) -> int
                    val sum :
                      (module Base__.Commutative_group.S with type t = 'sum) ->
                      'a t -> f:('-> 'sum) -> 'sum
                    val find : 'a t -> f:('-> bool) -> 'a option
                    val find_map : 'a t -> f:('-> 'b option) -> 'b option
                    val to_list : 'a t -> 'a list
                    val to_array : 'a t -> 'a array
                    val min_elt : 'a t -> cmp:('-> '-> int) -> 'a option
                    val max_elt : 'a t -> cmp:('-> '-> int) -> 'a option
                    val invariant : 'a t -> Core_kernel__.Import.unit
                    val create :
                      ?growth_allowed:Core_kernel__.Import.bool ->
                      ?size:Core_kernel__.Import.int ->
                      Core_kernel__.Import.unit -> 'a t
                    val clear : 'a t -> Core_kernel__.Import.unit
                    val mem : 'a t -> Key.t -> Core_kernel__.Import.bool
                    val lookup :
                      'a t -> Key.t -> 'Core_kernel__.Import.option
                    val lookup_exn : 'a t -> Key.t -> 'a
                    val enqueue :
                      'a t -> Key.t -> '-> [ `Key_already_present | `Ok ]
                    val enqueue_exn :
                      'a t -> Key.t -> '-> Core_kernel__.Import.unit
                    val lookup_and_move_to_back :
                      'a t -> Key.t -> 'Core_kernel__.Import.option
                    val lookup_and_move_to_back_exn : 'a t -> Key.t -> 'a
                    val first : 'a t -> 'Core_kernel__.Import.option
                    val first_with_key :
                      'a t -> (Key.t * 'a) Core_kernel__.Import.option
                    val keys : 'a t -> Key.t Core_kernel__.Import.list
                    val dequeue : 'a t -> 'Core_kernel__.Import.option
                    val dequeue_exn : 'a t -> 'a
                    val dequeue_with_key :
                      'a t -> (Key.t * 'a) Core_kernel__.Import.option
                    val dequeue_with_key_exn : 'a t -> Key.t * 'a
                    val dequeue_all :
                      'a t ->
                      f:('-> Core_kernel__.Import.unit) ->
                      Core_kernel__.Import.unit
                    val remove : 'a t -> Key.t -> [ `No_such_key | `Ok ]
                    val remove_exn :
                      'a t -> Key.t -> Core_kernel__.Import.unit
                    val replace :
                      'a t -> Key.t -> '-> [ `No_such_key | `Ok ]
                    val replace_exn :
                      'a t -> Key.t -> '-> Core_kernel__.Import.unit
                    val iteri :
                      'a t ->
                      f:(key:Key.t -> data:'-> Core_kernel__.Import.unit) ->
                      Core_kernel__.Import.unit
                    val foldi :
                      'a t ->
                      init:'-> f:('-> key:Key.t -> data:'-> 'b) -> 'b
                  end
                val to_string : t -> string
                val str : unit -> t -> string
                val pps : unit -> t -> string
                val ppo : Core_kernel.Std.Out_channel.t -> t -> unit
                val pp_seq :
                  Format.formatter -> t Core_kernel.Std.Sequence.t -> unit
                val pp : Base__.Import.Caml.Format.formatter -> t -> unit
              end
          val fixpoint :
            (module Graphlib.Std.Graph with type node = 'and type t = 'c) ->
            ?steps:int ->
            ?start:'->
            ?rev:bool ->
            ?step:(int -> '-> '-> '-> 'd) ->
            init:('n, 'd) Graphlib.Std.Solution.t ->
            equal:('-> '-> bool) ->
            merge:('-> '-> 'd) ->
            f:('-> '-> 'd) -> '-> ('n, 'd) Graphlib.Std.Solution.t
          type scheme
          type 'a symbolizer = '-> string
          val create_scheme :
            next:(string -> string) -> string -> Graphlib.Std.Graphlib.scheme
          val symbols : Graphlib.Std.Graphlib.scheme
          val numbers : Graphlib.Std.Graphlib.scheme
          val nothing : Graphlib.Std.Graphlib.scheme
          val by_given_order :
            Graphlib.Std.Graphlib.scheme ->
            ('-> '-> int) ->
            'Core_kernel.Std.Sequence.t ->
            'Graphlib.Std.Graphlib.symbolizer
          val by_natural_order :
            Graphlib.Std.Graphlib.scheme ->
            ('-> '-> int) ->
            'Core_kernel.Std.Sequence.t ->
            'Graphlib.Std.Graphlib.symbolizer
          module Dot :
            sig
              val pp_graph :
                ?name:string ->
                ?attrs:string list ->
                ?string_of_node:'Graphlib.Std.Graphlib.symbolizer ->
                ?node_label:'Graphlib.Std.Graphlib.symbolizer ->
                ?edge_label:'Graphlib.Std.Graphlib.symbolizer ->
                nodes_of_edge:('-> 'n * 'n) ->
                nodes:'Core_kernel.Std.Sequence.t ->
                edges:'Core_kernel.Std.Sequence.t ->
                Format.formatter -> unit
            end
        end
    end
end